home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / ld / dist / ld.diff2 < prev    next >
Encoding:
Text File  |  1990-10-26  |  142.1 KB  |  5,130 lines
  1. *** ld.original    Thu Oct 25 22:09:56 1990
  2. --- /tmp/jhh/binutils/ld.c    Thu Jun 21 14:52:49 1990
  3. ***************
  4. *** 23,37 ****
  5. --- 23,60 ----
  6.   #include <sys/types.h>
  7.   #include <sys/stat.h>
  8.   #include <sys/file.h>
  9. + #ifndef USG
  10. + #include <sys/time.h>
  11. + #include <sys/resource.h>
  12. + #endif
  13.   #ifndef sony_news
  14.   #include <fcntl.h>
  15.   #endif
  16.   
  17. + #if !defined(A_OUT) && !defined(MACH_O)
  18. + #define A_OUT
  19. + #endif
  20. + 
  21. + #ifdef A_OUT
  22.   #ifdef COFF_ENCAPSULATE
  23.   #include "a.out.encap.h"
  24.   #else
  25.   #include <a.out.h>
  26.   #endif
  27. + #endif
  28. + 
  29. + #ifdef MACH_O
  30. + #ifndef A_OUT
  31. + #include <nlist.h>
  32. + #include <reloc.h>
  33. + #endif
  34. + #ifndef N_TEXT
  35. + #define N_TEXT 0x04
  36. + #define N_DATA 0x06
  37. + #define N_BSS 0x08
  38. + #endif
  39. + #include <sys/loader.h>
  40. + #endif
  41.   
  42.   #ifndef N_SET_MAGIC
  43.   #define N_SET_MAGIC(exec, val)  ((exec).a_magic = val)
  44. ***************
  45. *** 40,46 ****
  46. --- 63,77 ----
  47.   /* If compiled with GNU C, use the built-in alloca */
  48.   #ifdef __GNUC__
  49.   # define alloca __builtin_alloca
  50. + #else
  51. + # if defined(sun) && defined(sparc)
  52. + #  include "alloca.h"
  53. + # else
  54. + char *alloca ();
  55.   # endif
  56. + #endif
  57. + 
  58. + #include "getopt.h"
  59.   
  60.   /* Always use the GNU version of debugging symbol type codes, if possible.  */
  61.   
  62. ***************
  63. *** 86,102 ****
  64.   /* Define this to specify the default executable format.  */
  65.   
  66.   #ifdef hpux
  67. ! #define DEFAULT_MAGIC NMAGIC  /* hpux bugs screw ZMAGIC */
  68. ! #endif
  69. ! 
  70. ! #ifndef DEFAULT_MAGIC
  71. ! #define DEFAULT_MAGIC ZMAGIC
  72.   #endif
  73.   
  74.   /* Ordinary 4.3bsd lacks these macros in a.out.h.  */
  75.   
  76.   #ifndef N_TXTADDR
  77. ! #if defined(vax) || defined(sony_news)
  78.   #define N_TXTADDR(X) 0
  79.   #endif
  80.   #ifdef is68k
  81. --- 117,129 ----
  82.   /* Define this to specify the default executable format.  */
  83.   
  84.   #ifdef hpux
  85. ! #define DEFAULT_OUTPUT_STYLE OUTPUT_READONLY_TEXT
  86.   #endif
  87.   
  88.   /* Ordinary 4.3bsd lacks these macros in a.out.h.  */
  89.   
  90.   #ifndef N_TXTADDR
  91. ! #if defined(vax) || defined(sony_news) || defined(hp300) || defined(pyr)
  92.   #define N_TXTADDR(X) 0
  93.   #endif
  94.   #ifdef is68k
  95. ***************
  96. *** 105,114 ****
  97.   #ifdef sequent
  98.   #define    N_TXTADDR(x) (N_ADDRADJ(x))
  99.   #endif
  100.   #endif
  101.   
  102.   #ifndef N_DATADDR
  103. ! #if defined(vax) || defined(sony_news)
  104.   #define N_DATADDR(x) \
  105.       (((x).a_magic==OMAGIC)? (N_TXTADDR(x)+(x).a_text) \
  106.       : (page_size+((N_TXTADDR(x)+(x).a_text-1) & ~(page_size-1))))
  107. --- 132,144 ----
  108.   #ifdef sequent
  109.   #define    N_TXTADDR(x) (N_ADDRADJ(x))
  110.   #endif
  111. + #ifdef NeXT
  112. + #define N_TXTADDR(X) ((X).a_magic == ZMAGIC ? page_size : 0)
  113. + #endif
  114.   #endif
  115.   
  116.   #ifndef N_DATADDR
  117. ! #if defined(vax) || defined(sony_news) || defined(hp300) || defined(pyr)
  118.   #define N_DATADDR(x) \
  119.       (((x).a_magic==OMAGIC)? (N_TXTADDR(x)+(x).a_text) \
  120.       : (page_size+((N_TXTADDR(x)+(x).a_text-1) & ~(page_size-1))))
  121. ***************
  122. *** 124,130 ****
  123. --- 154,172 ----
  124.       (((x).a_magic==OMAGIC)? (N_TXTADDR(x)+(x).a_text) \
  125.       : (page_size+(((x).a_text-1) & ~(page_size-1))))
  126.   #endif
  127. + #ifdef NeXT
  128. + #define N_DATADDR(X) \
  129. +     (((X).a_magic==ZMAGIC)?(N_TXTADDR(X)+(X).a_text+0xFFFF)&~0xFFFF \
  130. +      :N_TXTADDR(X)+(X).a_text)
  131.   #endif
  132. + #endif
  133. + 
  134. + /* The "address" of the data segment in a relocatable file.
  135. +    The text address of a relocatable file is always
  136. +    considered to be zero (instead of the value of N_TXTADDR, which
  137. +    is what the address is in an executable), so we need to subtract
  138. +    N_TXTADDR from N_DATADDR to get the "address" for the input file.  */
  139. + #define DATA_ADDR_DOT_O(hdr) (N_DATADDR(hdr) - N_TXTADDR(hdr))
  140.   
  141.   /* Define how to initialize system-dependent header fields.  */
  142.   #ifdef sun
  143. ***************
  144. *** 131,144 ****
  145.   #ifdef sparc
  146.   #define INITIALIZE_HEADER \
  147.     {outheader.a_machtype = M_SPARC; outheader.a_toolversion = 1;}
  148. ! #endif
  149. ! #if defined(mc68010) || defined(m68010)
  150. ! #define INITIALIZE_HEADER outheader.a_machtype = M_68010
  151. ! #endif
  152. ! #ifndef INITIALIZE_HEADER
  153. ! #define INITIALIZE_HEADER outheader.a_machtype = M_68020
  154. ! #endif
  155. ! #endif
  156.   #ifdef ALTOS
  157.   #define INITIALIZE_HEADER N_SET_MACHTYPE (outheader, M_68020)
  158.   #endif
  159. --- 173,195 ----
  160.   #ifdef sparc
  161.   #define INITIALIZE_HEADER \
  162.     {outheader.a_machtype = M_SPARC; outheader.a_toolversion = 1;}
  163. ! #endif /* sparc.  */
  164. ! #if defined(mc68000)
  165. ! /* Set the machine type according to the machine type of the .o files.
  166. !    If they are all sun2 (68010), then the type of the executable is sun2.
  167. !    If any is sun3 (68020), then the type of the executable is sun3.
  168. !    This is consistent with the Sun loader and more useful than having
  169. !    it depend on which machine you are on when you run ld.  */
  170. ! static int sun_machtype = M_68010;
  171. ! #define INITIALIZE_HEADER outheader.a_machtype = sun_machtype
  172. ! #define READ_HEADER_HOOK(machtype) \
  173. !   if (machtype == M_68020)           \
  174. !     {                     \
  175. !       sun_machtype = M_68020;         \
  176. !     }
  177. ! #endif /* mc68000.  */
  178. ! #endif /* Sun.  */
  179. ! 
  180.   #ifdef ALTOS
  181.   #define INITIALIZE_HEADER N_SET_MACHTYPE (outheader, M_68020)
  182.   #endif
  183. ***************
  184. *** 155,161 ****
  185.   #endif
  186.   #if defined(i386) && !defined(sequent)
  187.   #define INITIALIZE_HEADER N_SET_MACHTYPE (outheader, M_386)
  188. ! #endif
  189.   
  190.   #ifdef is68k
  191.   /* This enables code to take care of an ugly hack in the ISI OS.
  192. --- 206,218 ----
  193.   #endif
  194.   #if defined(i386) && !defined(sequent)
  195.   #define INITIALIZE_HEADER N_SET_MACHTYPE (outheader, M_386)
  196. ! #endif /* Sequent symmetry.  */
  197. ! #if defined(hp300)
  198. ! #define INITIALIZE_HEADER outheader.a_mid = MID_HP300
  199. ! #endif /* hp300.  */
  200. ! #ifdef pyr
  201. ! #define INITIALIZE_HEADER outheader.a_machid = PYR90X
  202. ! #endif /* Pyramid.  */
  203.   
  204.   #ifdef is68k
  205.   /* This enables code to take care of an ugly hack in the ISI OS.
  206. ***************
  207. *** 164,179 ****
  208.   #define DOLLAR_KLUDGE
  209.   #endif
  210.   
  211. ! /*
  212. !  * Alloca include.
  213. !  */
  214. ! #if defined(sun) && defined(sparc) && !defined(__GNUC__)
  215. ! #include "alloca.h"
  216. ! #endif
  217. ! 
  218.   #ifndef L_SET
  219.   #define L_SET 0
  220.   #endif
  221.   
  222.   /*
  223.    * Ok.  Following are the relocation information macros.  If your
  224. --- 221,234 ----
  225.   #define DOLLAR_KLUDGE
  226.   #endif
  227.   
  228. ! /* Values for 3rd argument to lseek().  */
  229.   #ifndef L_SET
  230.   #define L_SET 0
  231.   #endif
  232. + /* This is called L_INCR in BSD, but SEEK_CUR in POSIX.  */
  233. + #ifndef SEEK_CUR
  234. + #define SEEK_CUR 1
  235. + #endif
  236.   
  237.   /*
  238.    * Ok.  Following are the relocation information macros.  If your
  239. ***************
  240. *** 193,199 ****
  241.    * what the value of the relocation actually was.  *Must be an lvalue*.
  242.    *
  243.    *   RELOC_TYPE (rval): For a non-external relocation, this is the
  244. !  * segment to relocate for.
  245.    *
  246.    *   RELOC_SYMBOL (rval): For an external relocation, this is the
  247.    * index of its symbol in the symbol table.  *Must be an lvalue*.
  248. --- 248,254 ----
  249.    * what the value of the relocation actually was.  *Must be an lvalue*.
  250.    *
  251.    *   RELOC_TYPE (rval): For a non-external relocation, this is the
  252. !  * segment to relocate for.  *Must be an lvalue.*
  253.    *
  254.    *   RELOC_SYMBOL (rval): For an external relocation, this is the
  255.    * index of its symbol in the symbol table.  *Must be an lvalue*.
  256. ***************
  257. *** 502,508 ****
  258.         /* Nonzero means definitions of this symbol as common have been seen,
  259.        and the value here is the largest size specified by any of them.  */
  260.         int max_common_size;
  261. !       /* For relocatable_output, records the index of this global sym in the
  262.        symbol table to be written, with the first global sym given index 0.*/
  263.         int def_count;
  264.         /* Nonzero means a definition of this global symbol is known to exist.
  265. --- 557,563 ----
  266.         /* Nonzero means definitions of this symbol as common have been seen,
  267.        and the value here is the largest size specified by any of them.  */
  268.         int max_common_size;
  269. !       /* For OUTPUT_RELOCATABLE, records the index of this global sym in the
  270.        symbol table to be written, with the first global sym given index 0.*/
  271.         int def_count;
  272.         /* Nonzero means a definition of this global symbol is known to exist.
  273. ***************
  274. *** 530,535 ****
  275. --- 585,599 ----
  276.       }
  277.     symbol;
  278.   
  279. + /* Demangler for C++.  */
  280. + extern char *cplus_demangle ();
  281. + 
  282. + /* Demangler function to use.  We unconditionally enable the C++ demangler
  283. +    because we assume any name it successfully demangles was probably produced
  284. +    by the C++ compiler.  Enabling it only if -lg++ was specified seems too
  285. +    much of a kludge.  */
  286. + char *(*demangler)() = cplus_demangle;
  287. + 
  288.   /* Number of buckets in symbol hash table */
  289.   #define    TABSIZE    1009
  290.   
  291. ***************
  292. *** 611,620 ****
  293. --- 675,694 ----
  294.      -e sets this.  */
  295.   symbol *entry_symbol;
  296.   
  297. + /* These can be NULL if we don't actually have such a symbol.  */
  298.   symbol *edata_symbol;   /* the symbol _edata */
  299.   symbol *etext_symbol;   /* the symbol _etext */
  300.   symbol *end_symbol;    /* the symbol _end */
  301. + /* We also need __{edata,etext,end} so that they can safely
  302. +    be used from an ANSI library.  */
  303. + symbol *edata_symbol_alt;
  304. + symbol *etext_symbol_alt;
  305. + symbol *end_symbol_alt;
  306.   
  307. + /* Kinds of files potentially understood by the linker. */
  308. + 
  309. + enum file_type { IS_UNKNOWN, IS_ARCHIVE, IS_A_OUT, IS_MACH_O };
  310. + 
  311.   /* Each input file, and each library member ("subfile") being loaded,
  312.      has a `file_entry' structure for it.
  313.   
  314. ***************
  315. *** 630,659 ****
  316.   struct file_entry {
  317.     /* Name of this file.  */
  318.     char *filename;
  319.     /* Name to use for the symbol giving address of text start */
  320.     /* Usually the same as filename, but for a file spec'd with -l
  321.        this is the -l switch itself rather than the filename.  */
  322.     char *local_sym_name;
  323.   
  324. !   /* Describe the layout of the contents of the file */
  325.   
  326. !   /* The file's a.out header.  */
  327. !   struct exec header;
  328. !   /* Offset in file of GDB symbol segment, or 0 if there is none.  */
  329. !   int symseg_offset;
  330.   
  331.     /* Describe data from the file loaded into core */
  332.   
  333.     /* Symbol table of the file.  */
  334.     struct nlist *symbols;
  335. !   /* Size in bytes of string table.  */
  336. !   int string_size;
  337.     /* Pointer to the string table.
  338.        The string table is not kept in core all the time,
  339.        but when it is in core, its address is here.  */
  340.     char *strings;
  341.   
  342. !   /* Next two used only if `relocatable_output' or if needed for */
  343.     /* output of undefined reference line numbers. */
  344.   
  345.     /* Text reloc info saved by `write_text' for `coptxtrel'.  */
  346. --- 704,771 ----
  347.   struct file_entry {
  348.     /* Name of this file.  */
  349.     char *filename;
  350. + 
  351. +   /* What kind of file this is. */
  352. +   enum file_type file_type;
  353. + 
  354.     /* Name to use for the symbol giving address of text start */
  355.     /* Usually the same as filename, but for a file spec'd with -l
  356.        this is the -l switch itself rather than the filename.  */
  357.     char *local_sym_name;
  358.   
  359. !   /* Describe the layout of the contents of the file.  */
  360.   
  361. !   /* The text section. */
  362. !   unsigned long int orig_text_address;
  363. !   unsigned long int text_size;
  364. !   long int text_offset;
  365. ! 
  366. !   /* Text relocation. */
  367. !   unsigned long int text_reloc_size;
  368. !   long int text_reloc_offset;
  369. ! 
  370. !   /* The data section. */
  371. !   unsigned long int orig_data_address;
  372. !   unsigned long int data_size;
  373. !   long int data_offset;
  374. ! 
  375. !   /* Data relocation. */
  376. !   unsigned long int data_reloc_size;
  377. !   long int data_reloc_offset;
  378. ! 
  379. !   /* The bss section. */
  380. !   unsigned long int orig_bss_address;
  381. !   unsigned long int bss_size;
  382. ! 
  383. !   /* The symbol and string tables. */
  384. !   unsigned long int syms_size;
  385. !   long int syms_offset;
  386. !   unsigned long int strs_size;
  387. !   long int strs_offset;
  388. ! 
  389. !   /* The GDB symbol segment, if any. */
  390. !   unsigned long int symseg_size;
  391. !   long int symseg_offset;
  392. ! 
  393. ! #ifdef MACH_O
  394. !   /* Section ordinals from the Mach-O load commands.  These
  395. !      are compared with the n_sect fields of symbols.  */
  396. !   int text_ordinal;
  397. !   int data_ordinal;
  398. !   int bss_ordinal;
  399. ! #endif
  400.   
  401.     /* Describe data from the file loaded into core */
  402.   
  403.     /* Symbol table of the file.  */
  404.     struct nlist *symbols;
  405. ! 
  406.     /* Pointer to the string table.
  407.        The string table is not kept in core all the time,
  408.        but when it is in core, its address is here.  */
  409.     char *strings;
  410.   
  411. !   /* Next two used only if OUTPUT_RELOCATABLE or if needed for */
  412.     /* output of undefined reference line numbers. */
  413.   
  414.     /* Text reloc info saved by `write_text' for `coptxtrel'.  */
  415. ***************
  416. *** 724,751 ****
  417.   
  418.   char *output_filename;
  419.   
  420. ! /* Descriptor for writing that file with `mywrite'.  */
  421. ! 
  422. ! int outdesc;
  423.   
  424. ! /* Header for that file (filled in by `write_header').  */
  425.   
  426. ! struct exec outheader;
  427.   
  428. ! #ifdef COFF_ENCAPSULATE
  429. ! struct coffheader coffheader;
  430. ! int need_coff_header;
  431.   #endif
  432.   
  433.   /* The following are computed by `digest_symbols'.  */
  434.   
  435.   int text_size;        /* total size of text of all input files.  */
  436.   int data_size;        /* total size of data of all input files.  */
  437.   int bss_size;        /* total size of bss of all input files.  */
  438.   int text_reloc_size;    /* total size of text relocation of all input files.  */
  439. ! int data_reloc_size;    /* total size of data relocation of all input */
  440. !             /* files.  */
  441.   
  442.   /* Specifications of start and length of the area reserved at the end
  443.      of the text segment for the set vectors.  Computed in 'digest_symbols' */
  444.   int set_sect_start;
  445. --- 836,906 ----
  446.   
  447.   char *output_filename;
  448.   
  449. ! /* What kind of output file to write.  */
  450.   
  451. ! enum file_type output_file_type;
  452.   
  453. ! #ifndef DEFAULT_OUTPUT_FILE_TYPE
  454. ! #ifdef MACH_O
  455. ! #define DEFAULT_OUTPUT_FILE_TYPE IS_MACH_O
  456. ! #else
  457. ! #define DEFAULT_OUTPUT_FILE_TYPE IS_A_OUT
  458. ! #endif
  459. ! #endif
  460. ! 
  461. ! /* What `style' of output file to write.  For BSD a.out files
  462. !    this specifies OMAGIC, NMAGIC, or ZMAGIC.  For Mach-O files
  463. !    this switches between MH_OBJECT and two flavors of MH_EXECUTE.  */
  464. ! 
  465. ! enum output_style
  466. !   {
  467. !     OUTPUT_UNSPECIFIED,
  468. !     OUTPUT_RELOCATABLE,        /* -r */
  469. !     OUTPUT_WRITABLE_TEXT,    /* -N */
  470. !     OUTPUT_READONLY_TEXT,    /* -n */
  471. !     OUTPUT_DEMAND_PAGED        /* -Z (default) */
  472. !   };
  473. ! 
  474. ! enum output_style output_style;
  475.   
  476. ! #ifndef DEFAULT_OUTPUT_STYLE
  477. ! #define DEFAULT_OUTPUT_STYLE OUTPUT_DEMAND_PAGED
  478.   #endif
  479.   
  480. + /* Descriptor for writing that file with `mywrite'.  */
  481. + 
  482. + int outdesc;
  483. + 
  484.   /* The following are computed by `digest_symbols'.  */
  485.   
  486.   int text_size;            /* total size of text of all input files.  */
  487. + int text_header_size;        /* size of the file header if included in the
  488. +                    text size.  */
  489.   int data_size;            /* total size of data of all input files.  */
  490.   int bss_size;            /* total size of bss of all input files.  */
  491.   int text_reloc_size;        /* total size of text relocation of all input files.  */
  492. ! int data_reloc_size;        /* total size of data relocation of all input
  493. !                    files.  */
  494.     
  495. + /* The following are computed by write_header().  */
  496. + long int output_text_offset;    /* file offset of the text section.  */
  497. + long int output_data_offset;    /* file offset of the data section.  */
  498. + long int output_trel_offset;    /* file offset of the text relocation info.  */
  499. + long int output_drel_offset;    /* file offset of the data relocation info.  */
  500. + long int output_syms_offset;    /* file offset of the symbol table.  */
  501. + long int output_strs_offset;    /* file offset of the string table.  */
  502. + 
  503. + /* The following are incrementally computed by write_syms(); we keep
  504. +    them here so we can examine their values afterwards.  */
  505. + unsigned int output_syms_size;    /* total bytes of symbol table output. */
  506. + unsigned int output_strs_size;    /* total bytes of string table output. */
  507. + 
  508. + /* This can only be computed after the size of the string table is known.  */
  509. + long int output_symseg_offset;    /* file offset of the symbol segment (if any).  */
  510. + 
  511. + /* Incrementally computed by write_file_symseg().  */
  512. + unsigned int output_symseg_size;
  513. + 
  514.   /* Specifications of start and length of the area reserved at the end
  515.      of the text segment for the set vectors.  Computed in 'digest_symbols' */
  516.   int set_sect_start;
  517. ***************
  518. *** 755,766 ****
  519.      written. */
  520.   unsigned long *set_vectors;
  521.   
  522. ! /* Amount of cleared space to leave between the text and data segments.  */
  523.   
  524.   int text_pad;
  525.   
  526. ! /* Amount of bss segment to include as part of the data segment.  */
  527. ! 
  528.   int data_pad;
  529.   
  530.   /* Format of __.SYMDEF:
  531. --- 910,922 ----
  532.      written. */
  533.   unsigned long *set_vectors;
  534.   
  535. ! /* Amount of cleared space to leave at the end of the text segment.  */
  536.   
  537.   int text_pad;
  538.   
  539. ! /* Amount of padding at end of data segment.  This has two parts:
  540. !    That which is before the bss segment, and that which overlaps
  541. !    with the bss segment.  */
  542.   int data_pad;
  543.   
  544.   /* Format of __.SYMDEF:
  545. ***************
  546. *** 781,796 ****
  547.      write any padding in the output file for it.  */
  548.   int text_start;
  549.   
  550. - /* Offset of default entry-pc within the text section.  */
  551. - int entry_offset;
  552. - 
  553.   /* Address we decide the data section will be loaded at.  */
  554.   int data_start;
  555.   
  556. - /* `text-start' address is normally this much plus a page boundary.
  557. -    This is not a user option; it is fixed for each system.  */
  558. - int text_start_alignment;
  559. - 
  560.   /* Nonzero if -T was specified in the command line.
  561.      This prevents text_start from being set later to default values.  */
  562.   int T_flag_specified;
  563. --- 937,945 ----
  564. ***************
  565. *** 804,812 ****
  566.      and reduce the size of the bss section to match.  */
  567.   int specified_data_size;
  568.   
  569. - /* Magic number to use for the output file, set by switch.  */
  570. - int magic;
  571. - 
  572.   /* Nonzero means print names of input files as processed.  */
  573.   int trace_files;
  574.   
  575. --- 953,958 ----
  576. ***************
  577. *** 822,831 ****
  578.   /* 1 => write load map.  */
  579.   int write_map;
  580.   
  581. ! /* 1 => write relocation into output file so can re-input it later.  */
  582. ! int relocatable_output;
  583. ! 
  584. ! /* 1 => assign space to common symbols even if `relocatable_output'.  */
  585.   int force_common_definition;
  586.   
  587.   /* Standard directories to search for files specified by -l.  */
  588. --- 968,974 ----
  589.   /* 1 => write load map.  */
  590.   int write_map;
  591.   
  592. ! /* 1 => assign space to common symbols even if OUTPUT_RELOCATABLE. */
  593.   int force_common_definition;
  594.   
  595.   /* Standard directories to search for files specified by -l.  */
  596. ***************
  597. *** 840,845 ****
  598. --- 983,991 ----
  599.   #endif
  600.   #endif
  601.   
  602. + /* If set STANDARD_SEARCH_DIRS is not searched.  */
  603. + int no_standard_dirs;
  604. + 
  605.   /* Actual vector of directories to search;
  606.      this contains those specified with -L plus the standard ones.  */
  607.   char **search_dirs;
  608. ***************
  609. *** 847,854 ****
  610.   /* Length of the vector `search_dirs'.  */
  611.   int n_search_dirs;
  612.   
  613. ! /* Non zero means to create the output executable. */
  614. ! /* Cleared by nonfatal errors.  */
  615.   int make_executable;
  616.   
  617.   /* Force the executable to be output, even if there are non-fatal
  618. --- 993,1000 ----
  619.   /* Length of the vector `search_dirs'.  */
  620.   int n_search_dirs;
  621.   
  622. ! /* Non zero means to create the output executable.
  623. !    Cleared by nonfatal errors.  */
  624.   int make_executable;
  625.   
  626.   /* Force the executable to be output, even if there are non-fatal
  627. ***************
  628. *** 861,875 ****
  629.   struct glosym **cmdline_references;
  630.   int cl_refs_allocated;
  631.   
  632.   void bcopy (), bzero ();
  633. - int malloc (), realloc ();
  634. - #ifndef alloca
  635. - int alloca ();
  636.   #endif
  637. ! int free ();
  638.   
  639. ! int xmalloc ();
  640. ! int xrealloc ();
  641.   void fatal ();
  642.   void fatal_with_file ();
  643.   void perror_name ();
  644. --- 1007,1021 ----
  645.   struct glosym **cmdline_references;
  646.   int cl_refs_allocated;
  647.   
  648. + #ifndef bcopy
  649.   void bcopy (), bzero ();
  650.   #endif
  651. ! char *malloc (), *realloc ();
  652. ! void free ();
  653.   
  654. ! char *xmalloc ();
  655. ! char *xrealloc ();
  656. ! void usage ();
  657.   void fatal ();
  658.   void fatal_with_file ();
  659.   void perror_name ();
  660. ***************
  661. *** 876,881 ****
  662. --- 1022,1030 ----
  663.   void perror_file ();
  664.   void error ();
  665.   
  666. + int parse ();
  667. + void initialize_text_start ();
  668. + void initialize_data_start ();
  669.   void digest_symbols ();
  670.   void print_symbols ();
  671.   void load_symbols ();
  672. ***************
  673. *** 905,910 ****
  674. --- 1054,1070 ----
  675.     page_size = getpagesize ();
  676.     progname = argv[0];
  677.   
  678. + #ifdef RLIMIT_STACK
  679. +   /* Avoid dumping core on large .o files.  */
  680. +   {
  681. +     struct rlimit rl;
  682. + 
  683. +     getrlimit (RLIMIT_STACK, &rl);
  684. +     rl.rlim_cur = rl.rlim_max;
  685. +     setrlimit (RLIMIT_STACK, &rl);
  686. +   }
  687. + #endif
  688. + 
  689.     /* Clear the cumulative info on the output file.  */
  690.   
  691.     text_size = 0;
  692. ***************
  693. *** 924,934 ****
  694.     discard_locals = DISCARD_NONE;
  695.     entry_symbol = 0;
  696.     write_map = 0;
  697. -   relocatable_output = 0;
  698.     force_common_definition = 0;
  699.     T_flag_specified = 0;
  700.     Tdata_flag_specified = 0;
  701. -   magic = DEFAULT_MAGIC;
  702.     make_executable = 1;
  703.     force_executable = 0;
  704.     set_element_prefixes = 0;
  705. --- 1084,1092 ----
  706. ***************
  707. *** 947,952 ****
  708. --- 1105,1111 ----
  709.     common_defined_global_count = 0;
  710.   
  711.     /* Keep a list of symbols referenced from the command line */
  712. + 
  713.     cl_refs_allocated = 10;
  714.     cmdline_references
  715.       = (struct glosym **) xmalloc (cl_refs_allocated
  716. ***************
  717. *** 957,1004 ****
  718.   
  719.     decode_command (argc, argv);
  720.   
  721. -   /* Create the symbols `etext', `edata' and `end'.  */
  722. - 
  723. -   if (!relocatable_output)
  724. -     symtab_init ();
  725. - 
  726. -   /* Determine whether to count the header as part of
  727. -      the text size, and initialize the text size accordingly.
  728. -      This depends on the kind of system and on the output format selected.  */
  729. - 
  730. -   N_SET_MAGIC (outheader, magic);
  731. - #ifdef INITIALIZE_HEADER
  732. -   INITIALIZE_HEADER;
  733. - #endif
  734. - 
  735. -   text_size = sizeof (struct exec);
  736. - #ifdef COFF_ENCAPSULATE
  737. -   if (relocatable_output == 0)
  738. -     {
  739. -       need_coff_header = 1;
  740. -       /* set this flag now, since it will change the values of N_TXTOFF, etc */
  741. -       N_SET_FLAGS (outheader, N_FLAGS_COFF_ENCAPSULATE);
  742. -       text_size += sizeof (struct coffheader);
  743. -     }
  744. - #endif
  745. - 
  746. -   text_size -= N_TXTOFF (outheader);
  747. - 
  748. -   if (text_size < 0)
  749. -     text_size = 0;
  750. -   entry_offset = text_size;
  751. - 
  752. -   if (!T_flag_specified && !relocatable_output)
  753. -     text_start = N_TXTADDR (outheader);
  754. - 
  755. -   /* The text-start address is normally this far past a page boundary.  */
  756. -   text_start_alignment = text_start % page_size;
  757. - 
  758.     /* Load symbols of all input files.
  759.        Also search all libraries and decide which library members to load.  */
  760.   
  761.     load_symbols ();
  762.   
  763.     /* Compute where each file's sections go, and relocate symbols.  */
  764.   
  765.     digest_symbols ();
  766. --- 1116,1133 ----
  767.   
  768.     decode_command (argc, argv);
  769.   
  770.     /* Load symbols of all input files.
  771.        Also search all libraries and decide which library members to load.  */
  772.   
  773.     load_symbols ();
  774.   
  775. +   /* Create various built-in symbols.  This must occur after
  776. +      all input files are loaded so that a user program can have a
  777. +      symbol named etext (for example).  */
  778. + 
  779. +   if (output_style != OUTPUT_RELOCATABLE)
  780. +     symtab_init ();
  781. + 
  782.     /* Compute where each file's sections go, and relocate symbols.  */
  783.   
  784.     digest_symbols ();
  785. ***************
  786. *** 1020,1072 ****
  787.     exit (!make_executable);
  788.   }
  789.   
  790. ! void decode_option ();
  791.   
  792. ! /* Analyze a command line argument.
  793. !    Return 0 if the argument is a filename.
  794. !    Return 1 if the argument is a option complete in itself.
  795. !    Return 2 if the argument is a option which uses an argument.
  796. ! 
  797. !    Thus, the value is the number of consecutive arguments
  798. !    that are part of options.  */
  799. ! 
  800. ! int
  801. ! classify_arg (arg)
  802. !      register char *arg;
  803. ! {
  804. !   if (*arg != '-') return 0;
  805. !   switch (arg[1])
  806.       {
  807. !     case 'A':
  808. !     case 'D':
  809. !     case 'e':
  810. !     case 'L':
  811. !     case 'l':
  812. !     case 'o':
  813. !     case 'u':
  814. !     case 'V':
  815. !     case 'y':
  816. !       if (arg[2])
  817. !     return 1;
  818. !       return 2;
  819. ! 
  820. !     case 'B':
  821. !       if (! strcmp (&arg[2], "static"))
  822. !     return 1;
  823. ! 
  824. !     case 'T':
  825. !       if (arg[2] == 0)
  826. !     return 2;
  827. !       if (! strcmp (&arg[2], "text"))
  828. !     return 2;
  829. !       if (! strcmp (&arg[2], "data"))
  830. !     return 2;
  831. !       return 1;
  832. !     }
  833.   
  834. -   return 1;
  835. - }
  836. - 
  837.   /* Process the command arguments,
  838.      setting up file_table with an entry for each input file,
  839.      and setting variables according to the options.  */
  840. --- 1149,1191 ----
  841.     exit (!make_executable);
  842.   }
  843.   
  844. ! void add_cmdline_ref ();
  845.   
  846. ! static struct option longopts[] =
  847.   {
  848. !   {"d", 0, 0, 'd'},
  849. !   {"dc", 0, 0, 'd'},        /* For Sun compatibility. */
  850. !   {"dp", 0, 0, 'd'},        /* For Sun compatibility. */
  851. !   {"e", 1, 0, 'e'},
  852. !   {"n", 0, 0, 'n'},
  853. !   {"noinhibit-exec", 0, 0, 130},
  854. !   {"nostdlib", 0, 0, 133},
  855. !   {"o", 1, 0, 'o'},
  856. !   {"r", 0, 0, 'r'},
  857. !   {"s", 0, 0, 's'},
  858. !   {"t", 0, 0, 't'},
  859. !   {"u", 1, 0, 'u'},
  860. !   {"x", 0, 0, 'x'},
  861. !   {"z", 0, 0, 'z'},
  862. !   {"A", 1, 0, 'A'},
  863. !   {"Bstatic", 0, 0, 129},    /* For Sun compatibility. */
  864. !   {"D", 1, 0, 'D'},
  865. !   {"M", 0, 0, 'M'},
  866. !   {"N", 0, 0, 'N'},
  867. !   {"S", 0, 0, 'S'},
  868. !   {"T", 1, 0, 'T'},
  869. !   {"Ttext", 1, 0, 'T'},
  870. !   {"Tdata", 1, 0, 132},
  871. !   {"V", 1, 0, 'V'},
  872. !   {"X", 0, 0, 'X'},
  873. !   {0, 0, 0, 0}
  874. ! };
  875. ! 
  876. ! /* Since the Unix ld accepts -lfoo, -Lfoo, and -yfoo, we must also.
  877. !    This effectively prevents any long options from starting with
  878. !    one of these letters. */
  879. ! #define SHORTOPTS "-l:y:L:"
  880.   
  881.   /* Process the command arguments,
  882.      setting up file_table with an entry for each input file,
  883.      and setting variables according to the options.  */
  884. ***************
  885. *** 1076,1082 ****
  886.        char **argv;
  887.        int argc;
  888.   {
  889. !   register int i;
  890.     register struct file_entry *p;
  891.   
  892.     number_of_files = 0;
  893. --- 1195,1201 ----
  894.        char **argv;
  895.        int argc;
  896.   {
  897. !   int optc, longind;
  898.     register struct file_entry *p;
  899.   
  900.     number_of_files = 0;
  901. ***************
  902. *** 1085,1172 ****
  903.     n_search_dirs = 0;
  904.     search_dirs = (char **) xmalloc (sizeof (char *));
  905.   
  906. !   /* First compute number_of_files so we know how long to make file_table.  */
  907. !   /* Also process most options completely.  */
  908.   
  909. !   for (i = 1; i < argc; i++)
  910.       {
  911. !       register int code = classify_arg (argv[i]);
  912. !       if (code)
  913. !     {
  914. !       if (i + code > argc)
  915. !         fatal ("no argument following %s\n", argv[i]);
  916.   
  917. !       decode_option (argv[i], argv[i+1]);
  918.   
  919. !       if (argv[i][1] == 'l' || argv[i][1] == 'A')
  920.           number_of_files++;
  921.   
  922. !       i += code - 1;
  923.       }
  924. !       else
  925.       number_of_files++;
  926.       }
  927.   
  928.     if (!number_of_files)
  929. !     fatal ("no input files", 0);
  930.   
  931.     p = file_table
  932.       = (struct file_entry *) xmalloc (number_of_files * sizeof (struct file_entry));
  933.     bzero (p, number_of_files * sizeof (struct file_entry));
  934.   
  935. !   /* Now scan again and fill in file_table.  */
  936. !   /* All options except -A and -l are ignored here.  */
  937.   
  938. !   for (i = 1; i < argc; i++)
  939. !     {
  940. !       register int code = classify_arg (argv[i]);
  941.   
  942. !       if (code)
  943.       {
  944. !       char *string;
  945. !       if (code == 2)
  946. !         string = argv[i+1];
  947. !       else
  948. !         string = &argv[i][2];
  949.   
  950. !       if (argv[i][1] == 'A')
  951. !         {
  952.             if (p != file_table)
  953. !         fatal ("-A specified before an input file other than the first");
  954. ! 
  955. !           p->filename = string;
  956. !           p->local_sym_name = string;
  957.             p->just_syms_flag = 1;
  958.             p++;
  959. !         }
  960. !       if (argv[i][1] == 'l')
  961. !         {
  962. !           p->filename = concat ("lib", string, ".a");
  963. !           p->local_sym_name = concat ("-l", string, "");
  964.             p->search_dirs_flag = 1;
  965.             p++;
  966. !         }
  967. !       i += code - 1;
  968. !     }
  969. !       else
  970. !     {
  971. !       p->filename = argv[i];
  972. !       p->local_sym_name = argv[i];
  973. !       p++;
  974.       }
  975.       }
  976.   
  977.     /* Now check some option settings for consistency.  */
  978.   
  979. ! #ifdef NMAGIC
  980. !   if ((magic == ZMAGIC || magic == NMAGIC)
  981. ! #else
  982. !   if ((magic == ZMAGIC)
  983. ! #endif
  984.         && (text_start - text_start_alignment) & (page_size - 1))
  985. !     fatal ("-T argument not multiple of page size, with sharable output", 0);
  986.   
  987.     /* Append the standard search directories to the user-specified ones.  */
  988.     {
  989.       int n = sizeof standard_search_dirs / sizeof standard_search_dirs[0];
  990.       n_search_dirs += n;
  991. --- 1204,1429 ----
  992.     n_search_dirs = 0;
  993.     search_dirs = (char **) xmalloc (sizeof (char *));
  994.   
  995. !   /* First compute number_of_files so we know how long to make file_table.
  996. !      Also process most options completely.  */
  997.   
  998. !   while ((optc = getopt_long_only (argc, argv, SHORTOPTS, longopts, &longind))
  999. !      != EOF)
  1000. !     {
  1001. !       if (optc == 0)
  1002. !     optc = longopts[longind].val;
  1003. ! 
  1004. !       switch (optc)
  1005.       {
  1006. !     case '?':
  1007. !       usage (0, 0);
  1008. !       break;
  1009. ! 
  1010. !     case 1:
  1011. !       /* Non-option argument. */
  1012. !       number_of_files++;
  1013. !       break;
  1014. ! 
  1015. !     case 'd':
  1016. !       force_common_definition = 1;
  1017. !       break;
  1018.   
  1019. !     case 'e':
  1020. !       entry_symbol = getsym (optarg);
  1021. !       if (!entry_symbol->defined && !entry_symbol->referenced)
  1022. !         undefined_global_sym_count++;
  1023. !       entry_symbol->referenced = 1;
  1024. !       add_cmdline_ref (entry_symbol);
  1025. !       break;
  1026.   
  1027. !     case 'l':
  1028.         number_of_files++;
  1029. +       break;
  1030. + 
  1031. +     case 'n':
  1032. +       if (output_style && output_style != OUTPUT_READONLY_TEXT)
  1033. +         fatal ("illegal combination of -n with -N, -r, or -z", (char *) 0);
  1034. +       output_style = OUTPUT_READONLY_TEXT;
  1035. +       break;
  1036. + 
  1037. +     case 130:        /* -noinhibit-exec */
  1038. +       force_executable = 1;
  1039. +       break;
  1040. + 
  1041. +     case 133:        /* -nostdlib */
  1042. +       no_standard_dirs = 1;
  1043. +       break;
  1044. + 
  1045. +     case 'o':
  1046. +       output_filename = optarg;
  1047. +       break;
  1048. + 
  1049. +     case 'r':
  1050. +       if (output_style && output_style != OUTPUT_RELOCATABLE)
  1051. +         fatal ("illegal combination of -r with -N, -n, or -z", (char *) 0);
  1052. +       output_style = OUTPUT_RELOCATABLE;
  1053. +       text_start = 0;
  1054. +       break;
  1055. + 
  1056. +     case 's':
  1057. +       strip_symbols = STRIP_ALL;
  1058. +       break;
  1059. + 
  1060. +     case 't':
  1061. +       trace_files = 1;
  1062. +       break;
  1063. + 
  1064. +     case 'u':
  1065. +       {
  1066. +         register symbol *sp = getsym (optarg);
  1067.   
  1068. !         if (!sp->defined && !sp->referenced)
  1069. !           undefined_global_sym_count++;
  1070. !         sp->referenced = 1;
  1071. !         add_cmdline_ref (sp);
  1072.         }
  1073. !       break;
  1074. ! 
  1075. !     case 'x':
  1076. !       discard_locals = DISCARD_ALL;
  1077. !       break;
  1078. !       
  1079. !     case 'y':
  1080. !       {
  1081. !         register symbol *sp = getsym (optarg);
  1082. ! 
  1083. !         sp->trace = 1;
  1084. !       }
  1085. !       break;
  1086. ! 
  1087. !     case 'z':
  1088. !       if (output_style && output_style != OUTPUT_DEMAND_PAGED)
  1089. !         fatal ("illegal combination of -z with -N, -n, or -r", (char *) 0);
  1090. !       output_style = OUTPUT_DEMAND_PAGED;
  1091. !       break;
  1092. ! 
  1093. !     case 'A':
  1094.         number_of_files++;
  1095. +       break;
  1096. + 
  1097. +     case 129:        /* -Bstatic. */
  1098. +       /* Ignore. */
  1099. +       break;
  1100. + 
  1101. +     case 'D':
  1102. +       specified_data_size = parse (optarg, "%x", "invalid argument to -D");
  1103. +       break;
  1104. + 
  1105. +     case 'L':
  1106. +       n_search_dirs++;
  1107. +       search_dirs = (char **)
  1108. +         xrealloc (search_dirs, n_search_dirs * sizeof (char *));
  1109. +       search_dirs[n_search_dirs - 1] = optarg;
  1110. +       break;
  1111. +       
  1112. +     case 'M':
  1113. +       write_map = 1;
  1114. +       break;
  1115. + 
  1116. +     case 'N':
  1117. +       if (output_style && output_style != OUTPUT_WRITABLE_TEXT)
  1118. +         fatal ("illegal combination of -N with -n, -r, or -z", (char *) 0);
  1119. +       output_style = OUTPUT_WRITABLE_TEXT;
  1120. +       break;
  1121. + 
  1122. +     case 'S':
  1123. +       strip_symbols = STRIP_DEBUGGER;
  1124. +       break;
  1125. + 
  1126. +     case 'T':
  1127. +       text_start = parse (optarg, "%x", "invalid argument to -Ttext");
  1128. +       T_flag_specified = 1;
  1129. +       break;
  1130. + 
  1131. +     case 132:        /* -Tdata addr */
  1132. +       data_start = parse (optarg, "%x", "invalid argument to -Tdata");
  1133. +       Tdata_flag_specified = 1;
  1134. +       break;
  1135. + 
  1136. +     case 'V':
  1137. +       {
  1138. +         struct string_list_element *new
  1139. +           = (struct string_list_element *)
  1140. +         xmalloc (sizeof (struct string_list_element));
  1141. +         
  1142. +         new->str = optarg;
  1143. +         new->next = set_element_prefixes;
  1144. +         set_element_prefixes = new;
  1145. +       }
  1146. +       break;
  1147. + 
  1148. +     case 'X':
  1149. +       discard_locals = DISCARD_L;
  1150. +       break;
  1151.       }
  1152. +     }
  1153.   
  1154.     if (!number_of_files)
  1155. !     usage ("no input files", 0);
  1156.   
  1157.     p = file_table
  1158.       = (struct file_entry *) xmalloc (number_of_files * sizeof (struct file_entry));
  1159.     bzero (p, number_of_files * sizeof (struct file_entry));
  1160.   
  1161. !   /* Now scan again and fill in file_table.
  1162. !      All options except -A and -l are ignored here.  */
  1163.   
  1164. !   optind = 0;            /* Reset getopt. */
  1165. !   while ((optc = getopt_long_only (argc, argv, SHORTOPTS, longopts, &longind))
  1166. !      != EOF)
  1167. !     {
  1168. !       if (optc == 0)
  1169. !     optc = longopts[longind].val;
  1170.   
  1171. !       switch (optc)
  1172.       {
  1173. !     case 1:
  1174. !       /* Non-option argument. */
  1175. !       p->filename = optarg;
  1176. !       p->local_sym_name = optarg;
  1177. !       p++;
  1178. !       break;
  1179.   
  1180. !     case 'A':
  1181.         if (p != file_table)
  1182. !         usage ("-A specified before an input file other than the first");
  1183. !       p->filename = optarg;
  1184. !       p->local_sym_name = optarg;
  1185.         p->just_syms_flag = 1;
  1186.         p++;
  1187. !       break;
  1188. ! 
  1189. !     case 'l':
  1190. !       p->filename = concat ("lib", optarg, ".a");
  1191. !       p->local_sym_name = concat ("-l", optarg, "");
  1192.         p->search_dirs_flag = 1;
  1193.         p++;
  1194. !       break;
  1195.       }
  1196.       }
  1197.   
  1198. +   if (!output_file_type)
  1199. +     output_file_type = DEFAULT_OUTPUT_FILE_TYPE;
  1200. + 
  1201. +   if (!output_style)
  1202. +     output_style = DEFAULT_OUTPUT_STYLE;
  1203. + 
  1204. + #if 0
  1205. +   /* THIS CONSISTENCY CHECK BELONGS SOMEWHERE ELSE.  */
  1206.     /* Now check some option settings for consistency.  */
  1207.   
  1208. !   if ((output_style == OUTPUT_READONLY_TEXT || output_style == OUTPUT_DEMAND_PAGED)
  1209.         && (text_start - text_start_alignment) & (page_size - 1))
  1210. !     usage ("-T argument not multiple of page size, with sharable output", 0);
  1211. ! #endif
  1212.   
  1213.     /* Append the standard search directories to the user-specified ones.  */
  1214. +   if (!no_standard_dirs)
  1215.       {
  1216.         int n = sizeof standard_search_dirs / sizeof standard_search_dirs[0];
  1217.         n_search_dirs += n;
  1218. ***************
  1219. *** 1221,1384 ****
  1220.       }
  1221.     return 0;
  1222.   }
  1223. - 
  1224. - int parse ();
  1225. - 
  1226. - /* Record an option and arrange to act on it later.
  1227. -    ARG should be the following command argument,
  1228. -    which may or may not be used by this option.
  1229. - 
  1230. -    The `l' and `A' options are ignored here since they actually
  1231. -    specify input files.  */
  1232. - 
  1233. - void
  1234. - decode_option (swt, arg)
  1235. -      register char *swt, *arg;
  1236. - {
  1237. -   /* We get Bstatic from gcc on suns.  */
  1238. -   if (! strcmp (swt + 1, "Bstatic"))
  1239. -     return;
  1240. -   if (! strcmp (swt + 1, "Ttext"))
  1241. -     {
  1242. -       text_start = parse (arg, "%x", "invalid argument to -Ttext");
  1243. -       T_flag_specified = 1;
  1244. -       return;
  1245. -     }
  1246. -   if (! strcmp (swt + 1, "Tdata"))
  1247. -     {
  1248. -       data_start = parse (arg, "%x", "invalid argument to -Tdata");
  1249. -       Tdata_flag_specified = 1;
  1250. -       return;
  1251. -     }
  1252. -   if (! strcmp (swt + 1, "noinhibit-exec"))
  1253. -     {
  1254. -       force_executable = 1;
  1255. -       return;
  1256. -     }
  1257. - 
  1258. -   if (swt[2] != 0)
  1259. -     arg = &swt[2];
  1260. - 
  1261. -   switch (swt[1])
  1262. -     {
  1263. -     case 'A':
  1264. -       return;
  1265. - 
  1266. -     case 'D':
  1267. -       specified_data_size = parse (arg, "%x", "invalid argument to -D");
  1268. -       return;
  1269. - 
  1270. -     case 'd':
  1271. -       force_common_definition = 1;
  1272. -       return;
  1273. - 
  1274. -     case 'e':
  1275. -       entry_symbol = getsym (arg);
  1276. -       if (!entry_symbol->defined && !entry_symbol->referenced)
  1277. -     undefined_global_sym_count++;
  1278. -       entry_symbol->referenced = 1;
  1279. -       add_cmdline_ref (entry_symbol);
  1280. -       return;
  1281. - 
  1282. -     case 'l':
  1283. -       return;
  1284. - 
  1285. -     case 'L':
  1286. -       n_search_dirs++;
  1287. -       search_dirs
  1288. -     = (char **) xrealloc (search_dirs, n_search_dirs * sizeof (char *));
  1289. -       search_dirs[n_search_dirs - 1] = arg;
  1290. -       return;
  1291. - 
  1292. -     case 'M':
  1293. -       write_map = 1;
  1294. -       return;
  1295. - 
  1296. -     case 'N':
  1297. -       magic = OMAGIC;
  1298. -       return;
  1299. - 
  1300. - #ifdef NMAGIC
  1301. -     case 'n':
  1302. -       magic = NMAGIC;
  1303. -       return;
  1304. - #endif
  1305. - 
  1306. -     case 'o':
  1307. -       output_filename = arg;
  1308. -       return;
  1309. - 
  1310. -     case 'r':
  1311. -       relocatable_output = 1;
  1312. -       magic = OMAGIC;
  1313. -       text_start = 0;
  1314. -       return;
  1315. - 
  1316. -     case 'S':
  1317. -       strip_symbols = STRIP_DEBUGGER;
  1318. -       return;
  1319. - 
  1320. -     case 's':
  1321. -       strip_symbols = STRIP_ALL;
  1322. -       return;
  1323. - 
  1324. -     case 'T':
  1325. -       text_start = parse (arg, "%x", "invalid argument to -T");
  1326. -       T_flag_specified = 1;
  1327. -       return;
  1328. - 
  1329. -     case 't':
  1330. -       trace_files = 1;
  1331. -       return;
  1332. - 
  1333. -     case 'u':
  1334. -       {
  1335. -     register symbol *sp = getsym (arg);
  1336. -     if (!sp->defined && !sp->referenced)
  1337. -       undefined_global_sym_count++;
  1338. -     sp->referenced = 1;
  1339. -     add_cmdline_ref (sp);
  1340. -       }
  1341. -       return;
  1342. - 
  1343. -     case 'V':
  1344. -       {
  1345. -     struct string_list_element *new
  1346. -       = (struct string_list_element *)
  1347. -         xmalloc (sizeof (struct string_list_element));
  1348. - 
  1349. -     new->str = arg;
  1350. -     new->next = set_element_prefixes;
  1351. -     set_element_prefixes = new;
  1352. -     return;
  1353. -       }
  1354. - 
  1355. -     case 'X':
  1356. -       discard_locals = DISCARD_L;
  1357. -       return;
  1358. - 
  1359. -     case 'x':
  1360. -       discard_locals = DISCARD_ALL;
  1361. -       return;
  1362. - 
  1363. -     case 'y':
  1364. -       {
  1365. -     register symbol *sp = getsym (&swt[2]);
  1366. -     sp->trace = 1;
  1367. -       }
  1368. -       return;
  1369. - 
  1370. -     case 'z':
  1371. -       magic = ZMAGIC;
  1372. -       return;
  1373. - 
  1374. -     default:
  1375. -       fatal ("invalid command option `%s'", swt);
  1376. -     }
  1377. - }
  1378.   
  1379. ! /** Convenient functions for operating on one or all files being */
  1380. !  /** loaded.  */
  1381.   void print_file_name ();
  1382.   
  1383.   /* Call FUNCTION on each input file entry.
  1384. --- 1478,1486 ----
  1385.       }
  1386.     return 0;
  1387.   }
  1388.   
  1389. ! /* Convenient functions for operating on one or all files being
  1390. !    loaded.  */
  1391.   void print_file_name ();
  1392.   
  1393.   /* Call FUNCTION on each input file entry.
  1394. ***************
  1395. *** 1494,1502 ****
  1396.   
  1397.     if (input_file) file_close ();
  1398.   
  1399. !   if (entry->search_dirs_flag)
  1400.       {
  1401. -       register char **p = search_dirs;
  1402.         int i;
  1403.   
  1404.         for (i = 0; i < n_search_dirs; i++)
  1405. --- 1596,1603 ----
  1406.   
  1407.     if (input_file) file_close ();
  1408.   
  1409. !   if (entry->search_dirs_flag && n_search_dirs)
  1410.       {
  1411.         int i;
  1412.   
  1413.         for (i = 0; i < n_search_dirs; i++)
  1414. ***************
  1415. *** 1580,1588 ****
  1416.   
  1417.   /* Medium-level input routines for rel files.  */
  1418.   
  1419. ! /* Read a file's header into the proper place in the file_entry.
  1420.      DESC is the descriptor on which the file is open.
  1421. !    ENTRY is the file's entry.  */
  1422.   
  1423.   void
  1424.   read_header (desc, entry)
  1425. --- 1681,1971 ----
  1426.   
  1427.   /* Medium-level input routines for rel files.  */
  1428.   
  1429. ! /* Determine whether the given ENTRY is an archive, a BSD a.out file,
  1430. !    a Mach-O file, or whatever.  DESC is the descriptor on which the
  1431. !    file is open.  */
  1432. ! void
  1433. ! deduce_file_type(desc, entry)
  1434. !      int desc;
  1435. !      struct file_entry *entry;
  1436. ! {
  1437. !   int len;
  1438. ! 
  1439. !   {
  1440. !     char magic[SARMAG];
  1441. !     
  1442. !     lseek (desc, entry->starting_offset, 0);
  1443. !     len = read (desc, magic, SARMAG);
  1444. !     if (len == SARMAG && !strncmp(magic, ARMAG, SARMAG))
  1445. !       {
  1446. !     entry->file_type = IS_ARCHIVE;
  1447. !     return;
  1448. !       }
  1449. !   }
  1450. ! 
  1451. ! #ifdef A_OUT
  1452. !   {
  1453. !     struct exec hdr;
  1454. ! 
  1455. !     lseek (desc, entry->starting_offset, 0);
  1456. ! #ifdef COFF_ENCAPSULATE
  1457. !     if (entry->just_syms_flag)
  1458. !       /* Since a file given with -A will have a coff header, unlike normal
  1459. !     input files, we need to skip over it.  */
  1460. !       lseek (desc, sizeof (coffheader), SEEK_CUR);
  1461. ! #endif
  1462. !     len = read (desc, (char *) &hdr, sizeof (struct exec));
  1463. !     if (len == sizeof (struct exec) && !N_BADMAG (hdr))
  1464. !       {
  1465. !     entry->file_type = IS_A_OUT;
  1466. !     return;
  1467. !       }
  1468. !   }
  1469. ! #endif
  1470. ! 
  1471. ! #ifdef MACH_O
  1472. !   {
  1473. !     struct mach_header hdr;
  1474. ! 
  1475. !     lseek (desc, entry->starting_offset, 0);
  1476. !     len = read (desc, (char *) &hdr, sizeof (struct mach_header));
  1477. !     if (len == sizeof (struct mach_header) && hdr.magic == MH_MAGIC)
  1478. !       {
  1479. !     entry->file_type = IS_MACH_O;
  1480. !     return;
  1481. !       }
  1482. !   }
  1483. ! #endif
  1484. ! 
  1485. !   fatal_with_file ("malformed input file (not rel or archive) ", entry);
  1486. ! }
  1487. ! 
  1488. ! #ifdef A_OUT
  1489. ! /* Read an a.out file's header and set up the fields of
  1490. !    the ENTRY accordingly.  DESC is the descriptor on which
  1491. !    the file is open.  */
  1492. ! void
  1493. ! read_a_out_header (desc, entry)
  1494. !      int desc;
  1495. !      struct file_entry *entry;
  1496. ! {
  1497. !   register int len;
  1498. !   struct exec hdr;
  1499. !   struct stat st;
  1500. ! 
  1501. !   lseek (desc, entry->starting_offset, 0);
  1502. ! 
  1503. ! #ifdef COFF_ENCAPSULATE
  1504. !   if (entry->just_syms_flag)
  1505. !     /* Since a file given with -A will have a coff header, unlike normal
  1506. !        input files, we need to skip over it.  */
  1507. !     lseek (desc, sizeof (coffheader), SEEK_CUR);
  1508. ! #endif
  1509. ! 
  1510. !   read (desc, (char *) &hdr, sizeof (struct exec));
  1511. ! 
  1512. ! #ifdef READ_HEADER_HOOK
  1513. !   READ_HEADER_HOOK(hdr.a_machtype);
  1514. ! #endif
  1515. ! 
  1516. !   if (entry->just_syms_flag)
  1517. !     entry->orig_text_address = N_TXTADDR(hdr);
  1518. !   else
  1519. !     entry->orig_text_address = 0;
  1520. !   entry->text_size = hdr.a_text;
  1521. !   entry->text_offset = N_TXTOFF(hdr);
  1522. ! 
  1523. !   entry->text_reloc_size = hdr.a_trsize;
  1524. ! #ifdef N_TRELOFF
  1525. !   entry->text_reloc_offset = N_TRELOFF(hdr);
  1526. ! #else
  1527. ! #ifdef N_DATOFF
  1528. !   entry->text_reloc_offset = N_DATOFF(hdr) + hdr.a_data;
  1529. ! #else
  1530. !   entry->text_reloc_offset = N_TXTOFF(hdr) + hdr.a_text + hdr.a_data;
  1531. ! #endif
  1532. ! #endif
  1533. ! 
  1534. !   if (entry->just_syms_flag)
  1535. !     entry->orig_data_address = N_DATADDR(hdr);
  1536. !   else
  1537. !     entry->orig_data_address = entry->text_size;
  1538. !   entry->data_size = hdr.a_data;
  1539. ! #ifdef N_DATOFF
  1540. !   entry->data_offset = N_DATOFF(hdr);
  1541. ! #else
  1542. !   entry->data_offset = N_TXTOFF(hdr) + hdr.a_text;
  1543. ! #endif
  1544. ! 
  1545. !   entry->data_reloc_size = hdr.a_drsize;
  1546. ! #ifdef N_DRELOFF
  1547. !   entry->data_reloc_offset = N_DRELOFF(hdr);
  1548. ! #else
  1549. !   entry->data_reloc_offset = entry->text_reloc_offset + entry->text_reloc_size;
  1550. ! #endif
  1551. ! 
  1552. ! #ifdef N_BSSADDR
  1553. !   if (entry->just_syms_flag)
  1554. !     entry->orig_bss_address = N_BSSADDR(hdr);
  1555. !   else
  1556. ! #endif
  1557. !   entry->orig_bss_address = entry->orig_data_address + entry->data_size;
  1558. !   entry->bss_size = hdr.a_bss;
  1559. ! 
  1560. !   entry->syms_size = hdr.a_syms;
  1561. !   entry->syms_offset = N_SYMOFF(hdr);
  1562. !   entry->strs_offset = N_STROFF(hdr);
  1563. !   lseek(desc, entry->starting_offset + entry->strs_offset, 0);
  1564. !   if (read(desc, (char *) &entry->strs_size, sizeof (unsigned long int))
  1565. !       != sizeof (unsigned long int))
  1566. !     fatal_with_file ("failure reading string table size of ", entry);
  1567. ! 
  1568. !   if (!entry->superfile)
  1569. !     {
  1570. !       fstat(desc, &st);
  1571. !       if (st.st_size > entry->strs_offset + entry->strs_size)
  1572. !     {
  1573. !       entry->symseg_size = st.st_size - (entry->strs_offset + entry->strs_size);
  1574. !       entry->symseg_offset = entry->strs_offset + entry->strs_size;
  1575. !     }
  1576. !     }
  1577. !   else
  1578. !     if (entry->total_size > entry->strs_offset + entry->strs_size)
  1579. !       {
  1580. !     entry->symseg_size = entry->total_size - (entry->strs_offset + entry->strs_size);
  1581. !     entry->symseg_offset = entry->strs_offset + entry->strs_size;
  1582. !       }
  1583. ! }
  1584. ! #endif
  1585. ! 
  1586. ! #ifdef MACH_O
  1587. ! /* Read a Mach-O file's header.  DESC is the descriptor on which the
  1588. !    file is open, and ENTRY is the file's entry.  */
  1589. ! void
  1590. ! read_mach_o_header (desc, entry)
  1591. !      int desc;
  1592. !      struct file_entry *entry;
  1593. ! {
  1594. !   struct mach_header mach_header;
  1595. !   char *hdrbuf;
  1596. !   struct load_command *load_command;
  1597. !   struct segment_command *segment_command;
  1598. !   struct section *section;
  1599. !   struct symtab_command *symtab_command;
  1600. ! #ifdef LC_SYMSEG
  1601. !   struct symseg_command *symseg_command;
  1602. ! #endif;
  1603. !   int ordinal;
  1604. !   int symtab_seen, symseg_seen;
  1605. !   int len, cmd, seg;
  1606. ! 
  1607. !   entry->text_ordinal = entry->data_ordinal = entry->bss_ordinal = 0;
  1608. !   symtab_seen = symseg_seen = 0;
  1609. !   ordinal = 1;
  1610. ! 
  1611. !   lseek (desc, entry->starting_offset, 0);
  1612. !   len = read (desc, (char *) &mach_header, sizeof (struct mach_header));
  1613. !   if (len != sizeof (struct mach_header))
  1614. !     fatal_with_file ("failure reading Mach-O header of ", entry);
  1615. !   if (mach_header.filetype != MH_OBJECT && mach_header.filetype != MH_EXECUTE)
  1616. !     fatal_with_file ("unsupported Mach-O file type (not MH_OBJECT or MH_EXECUTE) in ", entry);
  1617. !   hdrbuf = xmalloc (mach_header.sizeofcmds);
  1618. !   len = read (desc, hdrbuf, mach_header.sizeofcmds);
  1619. !   if (len != mach_header.sizeofcmds)
  1620. !     fatal_with_file ("failure reading Mach-O load commands of ", entry);
  1621. !   load_command = (struct load_command *) hdrbuf;
  1622. !   for (cmd = 0; cmd < mach_header.ncmds; ++cmd)
  1623. !     {
  1624. !       switch (load_command->cmd)
  1625. !     {
  1626. !     case LC_SEGMENT:
  1627. !       segment_command = (struct segment_command *) load_command;
  1628. !       section = (struct section *) ((char *) (segment_command + 1));
  1629. !       for (seg = 0; seg < segment_command->nsects; ++seg, ++section, ++ordinal)
  1630. !         {
  1631. !           if (!strncmp(SECT_TEXT, section->sectname, sizeof section->sectname))
  1632. !         if (entry->text_ordinal)
  1633. !           fatal_with_file ("more than one __text section in ", entry);
  1634. !         else
  1635. !           {
  1636. !             entry->text_ordinal = ordinal;
  1637. !             entry->orig_text_address = section->addr;
  1638. !             entry->text_size = section->size;
  1639. !             entry->text_offset = section->offset;
  1640. !             entry->text_reloc_size = section->nreloc * sizeof (struct relocation_info);
  1641. !             entry->text_reloc_offset = section->reloff;
  1642. !           }
  1643. !           else if (!strncmp(SECT_DATA, section->sectname, sizeof section->sectname))
  1644. !         if (entry->data_ordinal)
  1645. !           fatal_with_file ("more than one __data section in ", entry);
  1646. !         else
  1647. !           {
  1648. !             entry->data_ordinal = ordinal;
  1649. !             entry->orig_data_address = section->addr;
  1650. !             entry->data_size = section->size;
  1651. !             entry->data_offset = section->offset;
  1652. !             entry->data_reloc_size = section->nreloc * sizeof (struct relocation_info);
  1653. !             entry->data_reloc_offset = section->reloff;
  1654. !           }
  1655. !           else if (!strncmp(SECT_BSS, section->sectname, sizeof section->sectname))
  1656. !         if (entry->bss_ordinal)
  1657. !           fatal_with_file ("more than one __bss section in ", entry);
  1658. !         else
  1659. !           {
  1660. !             entry->bss_ordinal = ordinal;
  1661. !             entry->orig_bss_address = section->addr;
  1662. !             entry->bss_size = section->size;
  1663. !           }
  1664. !           else
  1665. !         if (section->size != 0)
  1666. !           fprintf (stderr, "%s: warning: unknown section `%.*s' in %s\n",
  1667. !                progname, sizeof section->sectname, section->sectname,
  1668. !                entry->filename);
  1669. !         }
  1670. !       break;
  1671. !     case LC_SYMTAB:
  1672. !       if (symtab_seen)
  1673. !           fatal_with_file ("more than one LC_SYMTAB in ", entry);
  1674. !       else
  1675. !         {
  1676. !           symtab_seen = 1;
  1677. !           symtab_command = (struct symtab_command *) load_command;
  1678. !           entry->syms_size = symtab_command->nsyms * sizeof (struct nlist);
  1679. !           entry->syms_offset = symtab_command->symoff;
  1680. !           entry->strs_size = symtab_command->strsize;
  1681. !           entry->strs_offset = symtab_command->stroff;
  1682. !         }
  1683. !       break;
  1684. ! #ifdef LC_SYMSEG
  1685. !     case LC_SYMSEG:
  1686. !       if (symseg_seen)
  1687. !         fatal_with_file ("more than one LC_SYMSEG in ", entry);
  1688. !       else
  1689. !         {
  1690. !           symseg_seen = 1;
  1691. !           symseg_command = (struct symseg_command *) load_command;
  1692. !           entry->symseg_size = symseg_command->size;
  1693. !           entry->symseg_offset = symseg_command->offset;
  1694. !         }
  1695. !       break;
  1696. ! #endif
  1697. !     }
  1698. !       load_command = (struct load_command *)
  1699. !     ((char *) load_command + load_command->cmdsize);
  1700. !     }
  1701. ! 
  1702. !   free (hdrbuf);
  1703. ! 
  1704. !   if (!symtab_seen)
  1705. !     fprintf (stderr, "%s: no symbol table in %s\n", progname, entry->filename);
  1706. ! }
  1707. ! #endif
  1708. ! 
  1709. ! /* Read a file's header info into the proper place in the file_entry.
  1710.      DESC is the descriptor on which the file is open.
  1711. !    ENTRY is the file's entry.
  1712. !    Switch in the file_type to determine the appropriate actual
  1713. !    header reading routine to call.  */
  1714.   
  1715.   void
  1716.   read_header (desc, entry)
  1717. ***************
  1718. *** 1589,1611 ****
  1719.        int desc;
  1720.        register struct file_entry *entry;
  1721.   {
  1722. !   register int len;
  1723. !   struct exec *loc = (struct exec *) &entry->header;
  1724.   
  1725. !   lseek (desc, entry->starting_offset, 0);
  1726. !   len = read (desc, loc, sizeof (struct exec));
  1727. !   if (len != sizeof (struct exec))
  1728. !     fatal_with_file ("failure reading header of ", entry);
  1729. !   if (N_BADMAG (*loc))
  1730. !     fatal_with_file ("bad magic number in ", entry);
  1731.   
  1732.     entry->header_read_flag = 1;
  1733.   }
  1734.   
  1735.   /* Read the symbols of file ENTRY into core.
  1736. !    Assume it is already open, on descriptor DESC.
  1737. !    Also read the length of the string table, which follows the symbol table,
  1738. !    but don't read the contents of the string table.  */
  1739.   
  1740.   void
  1741.   read_entry_symbols (desc, entry)
  1742. --- 1972,2009 ----
  1743.        int desc;
  1744.        register struct file_entry *entry;
  1745.   {
  1746. !   if (!entry->file_type)
  1747. !     deduce_file_type (desc, entry);
  1748.   
  1749. !   switch (entry->file_type)
  1750. !     {
  1751. !     case IS_ARCHIVE:
  1752. !     default:
  1753. !       /* Should never happen. */
  1754. !       abort ();
  1755. ! 
  1756. ! #ifdef A_OUT
  1757. !     case IS_A_OUT:
  1758. !       read_a_out_header (desc, entry);
  1759. !       break;
  1760. ! #endif
  1761. ! 
  1762. ! #ifdef MACH_O
  1763. !     case IS_MACH_O:
  1764. !       read_mach_o_header (desc, entry);
  1765. !       break;
  1766. ! #endif
  1767. !     }
  1768.   
  1769.     entry->header_read_flag = 1;
  1770.   }
  1771.   
  1772. + #ifdef MACH_O
  1773. + void translate_mach_o_symbols ();
  1774. + #endif
  1775. + 
  1776.   /* Read the symbols of file ENTRY into core.
  1777. !    Assume it is already open, on descriptor DESC.  */
  1778.   
  1779.   void
  1780.   read_entry_symbols (desc, entry)
  1781. ***************
  1782. *** 1617,1638 ****
  1783.     if (!entry->header_read_flag)
  1784.       read_header (desc, entry);
  1785.   
  1786. !   entry->symbols = (struct nlist *) xmalloc (entry->header.a_syms);
  1787.   
  1788. !   lseek (desc, N_SYMOFF (entry->header) + entry->starting_offset, 0);
  1789. !   if (entry->header.a_syms != read (desc, entry->symbols, entry->header.a_syms))
  1790.       fatal_with_file ("premature end of file in symbols of ", entry);
  1791.   
  1792. !   lseek (desc, N_STROFF (entry->header) + entry->starting_offset, 0);
  1793. !   if (sizeof str_size != read (desc, &str_size, sizeof str_size))
  1794. !     fatal_with_file ("bad string table size in ", entry);
  1795. ! 
  1796. !   entry->string_size = str_size;
  1797.   }
  1798.   
  1799.   /* Read the string table of file ENTRY into core.
  1800. !    Assume it is already open, on descriptor DESC.
  1801. !    Also record whether a GDB symbol segment follows the string table.  */
  1802.   
  1803.   void
  1804.   read_entry_strings (desc, entry)
  1805. --- 2015,2034 ----
  1806.     if (!entry->header_read_flag)
  1807.       read_header (desc, entry);
  1808.   
  1809. !   entry->symbols = (struct nlist *) xmalloc (entry->syms_size);
  1810.   
  1811. !   lseek (desc, entry->syms_offset + entry->starting_offset, 0);
  1812. !   if (entry->syms_size != read (desc, entry->symbols, entry->syms_size))
  1813.       fatal_with_file ("premature end of file in symbols of ", entry);
  1814.   
  1815. ! #ifdef MACH_O
  1816. !   if (entry->file_type == IS_MACH_O)
  1817. !     translate_mach_o_symbols (entry);
  1818. ! #endif
  1819.   }
  1820.   
  1821.   /* Read the string table of file ENTRY into core.
  1822. !    Assume it is already open, on descriptor DESC.  */
  1823.   
  1824.   void
  1825.   read_entry_strings (desc, entry)
  1826. ***************
  1827. *** 1644,1671 ****
  1828.     if (!entry->header_read_flag)
  1829.       read_header (desc, entry);
  1830.   
  1831. !   lseek (desc, N_STROFF (entry->header) + entry->starting_offset, 0);
  1832. !   if (entry->string_size != read (desc, entry->strings, entry->string_size))
  1833.       fatal_with_file ("premature end of file in strings of ", entry);
  1834. - 
  1835. -   /* While we are here, see if the file has a symbol segment at the end.
  1836. -      For a separate file, just try reading some more.
  1837. -      For a library member, compare current pos against total size.  */
  1838. -   if (entry->superfile)
  1839. -     {
  1840. -       if (entry->total_size == N_STROFF (entry->header) + entry->string_size)
  1841. -     return;
  1842. -     }
  1843. -   else
  1844. -     {
  1845. -       buffer = read (desc, &buffer, sizeof buffer);
  1846. -       if (buffer == 0)
  1847. -     return;
  1848. -       if (buffer != sizeof buffer)
  1849. -     fatal_with_file ("premature end of file in GDB symbol segment of ", entry);
  1850. -     }
  1851. - 
  1852. -   entry->symseg_offset = N_STROFF (entry->header) + entry->string_size;
  1853.   }
  1854.   
  1855.   /* Read in the symbols of all input files.  */
  1856. --- 2040,2048 ----
  1857.     if (!entry->header_read_flag)
  1858.       read_header (desc, entry);
  1859.   
  1860. !   lseek (desc, entry->strs_offset + entry->starting_offset, 0);
  1861. !   if (entry->strs_size != read (desc, entry->strings, entry->strs_size))
  1862.       fatal_with_file ("premature end of file in strings of ", entry);
  1863.   }
  1864.   
  1865.   /* Read in the symbols of all input files.  */
  1866. ***************
  1867. *** 1698,1730 ****
  1868.        register struct file_entry *entry;
  1869.   {
  1870.     register int desc;
  1871. -   register int len;
  1872. -   struct exec hdr;
  1873.   
  1874.     desc = file_open (entry);
  1875.   
  1876. !   len = read (desc, &hdr, sizeof hdr);
  1877. !   if (len != sizeof hdr)
  1878. !     fatal_with_file ("failure reading header of ", entry);
  1879.   
  1880. !   if (!N_BADMAG (hdr))
  1881.       {
  1882.         read_entry_symbols (desc, entry);
  1883. !       entry->strings = (char *) alloca (entry->string_size);
  1884.         read_entry_strings (desc, entry);
  1885.         enter_file_symbols (entry);
  1886.         entry->strings = 0;
  1887.       }
  1888. -   else
  1889. -     {
  1890. -       char armag[SARMAG];
  1891. - 
  1892. -       lseek (desc, 0, 0);
  1893. -       if (SARMAG != read (desc, armag, SARMAG) || strncmp (armag, ARMAG, SARMAG))
  1894. -     fatal_with_file ("malformed input file (not rel or archive) ", entry);
  1895. -       entry->library_flag = 1;
  1896. -       search_library (desc, entry);
  1897. -     }
  1898.   
  1899.     file_close ();
  1900.   }
  1901. --- 2075,2099 ----
  1902.        register struct file_entry *entry;
  1903.   {
  1904.     register int desc;
  1905.   
  1906.     desc = file_open (entry);
  1907.   
  1908. !   if (!entry->file_type)
  1909. !     deduce_file_type (desc, entry);
  1910.   
  1911. !   if (entry->file_type == IS_ARCHIVE)
  1912. !     {
  1913. !       entry->library_flag = 1;
  1914. !       search_library (desc, entry);
  1915. !     }
  1916. !   else
  1917.       {
  1918.         read_entry_symbols (desc, entry);
  1919. !       entry->strings = (char *) alloca (entry->strs_size);
  1920.         read_entry_strings (desc, entry);
  1921.         enter_file_symbols (entry);
  1922.         entry->strings = 0;
  1923.       }
  1924.   
  1925.     file_close ();
  1926.   }
  1927. ***************
  1928. *** 1737,1744 ****
  1929.   {
  1930.     register struct nlist
  1931.       *p,
  1932. !     *end = entry->symbols + entry->header.a_syms / sizeof (struct nlist);
  1933. !   int lowest_set_vector = -1;
  1934.   
  1935.     if (trace_files) prline_file_name (entry, stderr);
  1936.   
  1937. --- 2106,2112 ----
  1938.   {
  1939.     register struct nlist
  1940.       *p,
  1941. !     *end = entry->symbols + entry->syms_size / sizeof (struct nlist);
  1942.   
  1943.     if (trace_files) prline_file_name (entry, stderr);
  1944.   
  1945. ***************
  1946. *** 1752,1758 ****
  1947.         if (SET_ELEMENT_P (p->n_type))
  1948.       {
  1949.         set_symbol_count++;
  1950. !       if (!relocatable_output)
  1951.           enter_global_ref (p, p->n_un.n_strx + entry->strings, entry);
  1952.       }
  1953.         else if (p->n_type == N_WARNING)
  1954. --- 2120,2126 ----
  1955.         if (SET_ELEMENT_P (p->n_type))
  1956.       {
  1957.         set_symbol_count++;
  1958. !       if (output_style != OUTPUT_RELOCATABLE)
  1959.           enter_global_ref (p, p->n_un.n_strx + entry->strings, entry);
  1960.       }
  1961.         else if (p->n_type == N_WARNING)
  1962. ***************
  1963. *** 1862,1869 ****
  1964. --- 2230,2242 ----
  1965.         /* Indirect symbols value should be modified to point
  1966.            a symbol being equivalenced to. */
  1967.         nlist_p->n_value
  1968. + #ifndef NeXT
  1969.           = (unsigned int) getsym ((nlist_p + 1)->n_un.n_strx
  1970.                        + entry->strings);
  1971. + #else
  1972. +         /* NeXT also has indirection but they do it weirdly. */
  1973. +         = (unsigned int) getsym (nlist_p->n_value + entry->strings);
  1974. + #endif
  1975.         if ((symbol *) nlist_p->n_value == sp)
  1976.           {
  1977.             /* Somebody redefined a symbol to be itself.  */
  1978. ***************
  1979. *** 1909,1915 ****
  1980.     if (sp->trace)
  1981.       {
  1982.         register char *reftype;
  1983. !       switch (type & N_TYPE)
  1984.       {
  1985.       case N_UNDF:
  1986.         if (nlist_p->n_value)
  1987. --- 2282,2288 ----
  1988.     if (sp->trace)
  1989.       {
  1990.         register char *reftype;
  1991. !       switch (type & ~N_EXT)
  1992.       {
  1993.       case N_UNDF:
  1994.         if (nlist_p->n_value)
  1995. ***************
  1996. *** 1954,1964 ****
  1997.         break;
  1998.   
  1999.       case N_INDR:
  2000. !       reftype = (char *) alloca (23
  2001. !                      + strlen ((nlist_p + 1)->n_un.n_strx
  2002. !                            + entry->strings));
  2003.         sprintf (reftype, "defined equivalent to %s",
  2004. !            (nlist_p + 1)->n_un.n_strx + entry->strings);
  2005.         break;
  2006.   
  2007.   #ifdef sequent
  2008. --- 2327,2335 ----
  2009.         break;
  2010.   
  2011.       case N_INDR:
  2012. !       reftype = (char *) alloca (23 + strlen (((symbol *) nlist_p->n_value)->name));
  2013.         sprintf (reftype, "defined equivalent to %s",
  2014. !            ((symbol *) nlist_p->n_value)->name);
  2015.         break;
  2016.   
  2017.   #ifdef sequent
  2018. ***************
  2019. *** 1975,1984 ****
  2020.         reftype = "shared BSS";
  2021.         break;
  2022.   */
  2023.       default:
  2024.         reftype = "I don't know this type";
  2025.         break;
  2026. - #endif
  2027.       }
  2028.   
  2029.         fprintf (stderr, "symbol %s %s in ", sp->name, reftype);
  2030. --- 2346,2356 ----
  2031.         reftype = "shared BSS";
  2032.         break;
  2033.   */
  2034. + #endif
  2035. + 
  2036.       default:
  2037.         reftype = "I don't know this type";
  2038.         break;
  2039.       }
  2040.   
  2041.         fprintf (stderr, "symbol %s %s in ", sp->name, reftype);
  2042. ***************
  2043. *** 1998,2004 ****
  2044.   {
  2045.     if (n_ptr >= entry->symbols &&
  2046.         n_ptr < (entry->symbols
  2047. !            + (entry->header.a_syms / sizeof (struct nlist))))
  2048.       return (unsigned long) entry;
  2049.     return 0;
  2050.   }
  2051. --- 2370,2376 ----
  2052.   {
  2053.     if (n_ptr >= entry->symbols &&
  2054.         n_ptr < (entry->symbols
  2055. !            + (entry->syms_size / sizeof (struct nlist))))
  2056.       return (unsigned long) entry;
  2057.     return 0;
  2058.   }
  2059. ***************
  2060. *** 2205,2211 ****
  2061.                + symdef_base[i].symbol_name_string_index,
  2062.                entry->filename);
  2063.           read_entry_symbols (desc, subentry);
  2064. !         subentry->strings = (char *) malloc (subentry->string_size);
  2065.           read_entry_strings (desc, subentry);
  2066.   
  2067.           /* Now scan the symbol table and decide whether to load.  */
  2068. --- 2577,2583 ----
  2069.                + symdef_base[i].symbol_name_string_index,
  2070.                entry->filename);
  2071.           read_entry_symbols (desc, subentry);
  2072. !         subentry->strings = xmalloc (subentry->strs_size);
  2073.           read_entry_strings (desc, subentry);
  2074.   
  2075.           /* Now scan the symbol table and decide whether to load.  */
  2076. ***************
  2077. *** 2213,2218 ****
  2078. --- 2585,2591 ----
  2079.           if (!subfile_wanted_p (subentry))
  2080.             {
  2081.               free (subentry->symbols);
  2082. +             free (subentry->strings);
  2083.               free (subentry);
  2084.             }
  2085.           else
  2086. ***************
  2087. *** 2238,2244 ****
  2088.               if (symdef_base[j].library_member_offset == offset)
  2089.                 symdef_base[j].symbol_name_string_index = -1;
  2090.                 }
  2091. -           }
  2092.   
  2093.           /* We'll read the strings again if we need them again.  */
  2094.           free (subentry->strings);
  2095. --- 2611,2616 ----
  2096. ***************
  2097. *** 2246,2251 ****
  2098. --- 2618,2624 ----
  2099.             }
  2100.             }
  2101.         }
  2102. +     }
  2103.   
  2104.     free (symdef_data);
  2105.   }
  2106. ***************
  2107. *** 2258,2267 ****
  2108.        register struct file_entry *subentry;
  2109.        struct file_entry **prev_addr, *entry;
  2110.   {
  2111. -   register struct file_entry *prev = *prev_addr;
  2112. - 
  2113.     read_entry_symbols (desc, subentry);
  2114. !   subentry->strings = (char *) alloca (subentry->string_size);
  2115.     read_entry_strings (desc, subentry);
  2116.   
  2117.     if (!subfile_wanted_p (subentry))
  2118. --- 2631,2638 ----
  2119.        register struct file_entry *subentry;
  2120.        struct file_entry **prev_addr, *entry;
  2121.   {
  2122.     read_entry_symbols (desc, subentry);
  2123. !   subentry->strings = (char *) alloca (subentry->strs_size);
  2124.     read_entry_strings (desc, subentry);
  2125.   
  2126.     if (!subfile_wanted_p (subentry))
  2127. ***************
  2128. *** 2273,2283 ****
  2129.       {
  2130.         enter_file_symbols (subentry);
  2131.   
  2132. !       if (prev)
  2133. !     prev->chain = subentry;
  2134.         else
  2135.       entry->subfiles = subentry;
  2136. !       prev = subentry;
  2137.         subentry->strings = 0; /* Since space will dissapear on return */
  2138.       }
  2139.   }
  2140. --- 2644,2654 ----
  2141.       {
  2142.         enter_file_symbols (subentry);
  2143.   
  2144. !       if (*prev_addr)
  2145. !     (*prev_addr)->chain = subentry;
  2146.         else
  2147.       entry->subfiles = subentry;
  2148. !       *prev_addr = subentry;
  2149.         subentry->strings = 0; /* Since space will dissapear on return */
  2150.       }
  2151.   }
  2152. ***************
  2153. *** 2319,2325 ****
  2154.   {
  2155.     register struct nlist *p;
  2156.     register struct nlist *end
  2157. !     = entry->symbols + entry->header.a_syms / sizeof (struct nlist);
  2158.   #ifdef DOLLAR_KLUDGE
  2159.     register int dollar_cond = 0;
  2160.   #endif
  2161. --- 2690,2696 ----
  2162.   {
  2163.     register struct nlist *p;
  2164.     register struct nlist *end
  2165. !     = entry->symbols + entry->syms_size / sizeof (struct nlist);
  2166.   #ifdef DOLLAR_KLUDGE
  2167.     register int dollar_cond = 0;
  2168.   #endif
  2169. ***************
  2170. *** 2367,2372 ****
  2171. --- 2738,2745 ----
  2172.         if (!sp) continue;
  2173.   
  2174.         if ((sp->referenced && !sp->defined)
  2175. +           /* NB.  This needs to be changed so that, e.g., "int pipe;" won't import
  2176. +          pipe() from the library.  But the bug fix kingdon made was wrong.  */
  2177.             || (sp->defined && sp->max_common_size))
  2178.           {
  2179.             /* This is a symbol we are looking for.  It is either
  2180. ***************
  2181. *** 2423,2428 ****
  2182. --- 2796,2807 ----
  2183.     if (trace_files)
  2184.       fprintf (stderr, "Digesting symbol information:\n\n");
  2185.   
  2186. +   /* Initialize the text_start address; this depends on the output file formats.  */
  2187. + 
  2188. +   initialize_text_start ();
  2189. + 
  2190. +   text_size = text_header_size;
  2191. + 
  2192.     /* Compute total size of sections */
  2193.   
  2194.     each_file (consider_file_section_lengths, 0);
  2195. ***************
  2196. *** 2430,2463 ****
  2197.     /* If necessary, pad text section to full page in the file.
  2198.        Include the padding in the text segment size.  */
  2199.   
  2200. ! #ifdef NMAGIC
  2201. !   if (magic == ZMAGIC || magic == NMAGIC)
  2202. ! #else
  2203. !   if (magic == ZMAGIC)
  2204. ! #endif
  2205.       {
  2206. !       int text_end = text_size + N_TXTOFF (outheader);
  2207. !       text_pad = ((text_end + page_size - 1) & (- page_size)) - text_end;
  2208.         text_size += text_pad;
  2209.       }
  2210.   
  2211. !   outheader.a_text = text_size;
  2212. ! #ifdef sequent
  2213. !   outheader.a_text += N_ADDRADJ (outheader);
  2214. ! #endif
  2215. ! 
  2216. !   /* Make the data segment address start in memory on a suitable boundary.  */
  2217.   
  2218. !   if (! Tdata_flag_specified)
  2219. !     data_start = N_DATADDR (outheader) + text_start - N_TXTADDR (outheader);
  2220.   
  2221.     /* Make sure bss starts out aligned as much as anyone can want.  */
  2222.   
  2223. !   data_size = (data_size + sizeof(double) - 1) & ~(sizeof(double)-1);
  2224.   
  2225.     /* Set up the set element vector */
  2226.   
  2227. !   if (!relocatable_output)
  2228.       {
  2229.         /* The set sector size is the number of set elements + a word
  2230.            for each symbol for the length word at the beginning of the
  2231. --- 2809,2836 ----
  2232.     /* If necessary, pad text section to full page in the file.
  2233.        Include the padding in the text segment size.  */
  2234.   
  2235. !   if (output_style == OUTPUT_READONLY_TEXT || output_style == OUTPUT_DEMAND_PAGED)
  2236.       {
  2237. !       text_pad = ((text_size + page_size - 1) & (- page_size)) - text_size;
  2238.         text_size += text_pad;
  2239.       }
  2240.   
  2241. !   /* Now that the text_size is known, initialize the data start address;
  2242. !      this depends on text_size as well as the output file format.  */
  2243.   
  2244. !   initialize_data_start ();
  2245.   
  2246.     /* Make sure bss starts out aligned as much as anyone can want.  */
  2247. +   {
  2248. +     int new_data_size = (data_size + sizeof(double) - 1) & ~(sizeof(double)-1);
  2249.   
  2250. !     data_pad += new_data_size - data_size;
  2251. !     data_size = new_data_size;
  2252. !   }
  2253.   
  2254.     /* Set up the set element vector */
  2255.   
  2256. !   if (output_style != OUTPUT_RELOCATABLE)
  2257.       {
  2258.         /* The set sector size is the number of set elements + a word
  2259.            for each symbol for the length word at the beginning of the
  2260. ***************
  2261. *** 2493,2499 ****
  2262.       {
  2263.         /* For each symbol */
  2264.         register struct nlist *p, *next;
  2265. !       int defs = 0, com = sp->max_common_size, erred = 0;
  2266.         struct nlist *first_definition;
  2267.         for (p = sp->refs; p; p = next)
  2268.           {
  2269. --- 2866,2872 ----
  2270.       {
  2271.         /* For each symbol */
  2272.         register struct nlist *p, *next;
  2273. !       int defs = 0, com = sp->max_common_size;
  2274.         struct nlist *first_definition;
  2275.         for (p = sp->refs; p; p = next)
  2276.           {
  2277. ***************
  2278. *** 2501,2507 ****
  2279.   
  2280.             if (SET_ELEMENT_P (type))
  2281.           {
  2282. !           if (relocatable_output)
  2283.               fatal ("internal: global ref to set element with -r");
  2284.             if (!defs++)
  2285.               {
  2286. --- 2874,2880 ----
  2287.   
  2288.             if (SET_ELEMENT_P (type))
  2289.           {
  2290. !           if (output_style == OUTPUT_RELOCATABLE)
  2291.               fatal ("internal: global ref to set element with -r");
  2292.             if (!defs++)
  2293.               {
  2294. ***************
  2295. *** 2535,2541 ****
  2296.         /* Allocate as common if defined as common and not defined for real */
  2297.         if (com && !defs)
  2298.           {
  2299. !           if (!relocatable_output || force_common_definition)
  2300.           {
  2301.             int align = sizeof (int);
  2302.   
  2303. --- 2908,2914 ----
  2304.         /* Allocate as common if defined as common and not defined for real */
  2305.         if (com && !defs)
  2306.           {
  2307. !           if (output_style != OUTPUT_RELOCATABLE || force_common_definition)
  2308.           {
  2309.             int align = sizeof (int);
  2310.   
  2311. ***************
  2312. *** 2604,2629 ****
  2313.   
  2314.     bss_size = (bss_size + sizeof(double) - 1) & ~(sizeof(double)-1);
  2315.   
  2316. !   if (end_symbol)        /* These are null if -r.  */
  2317.       {
  2318. !       etext_symbol->value = text_size + text_start;
  2319. !       edata_symbol->value = data_start + data_size;
  2320. !       end_symbol->value = data_start + data_size + bss_size;
  2321.       }
  2322.   
  2323.     /* Figure the data_pad now, so that it overlaps with the bss addresses.  */
  2324.   
  2325.     if (specified_data_size && specified_data_size > data_size)
  2326. !     data_pad = specified_data_size - data_size;
  2327.   
  2328. !   if (magic == ZMAGIC)
  2329. !     data_pad = ((data_pad + data_size + page_size - 1) & (- page_size))
  2330. !                - data_size;
  2331.   
  2332. !   bss_size -= data_pad;
  2333.     if (bss_size < 0) bss_size = 0;
  2334.   
  2335. !   data_size += data_pad;
  2336.   }
  2337.   
  2338.   /* Accumulate the section sizes of input file ENTRY
  2339. --- 2977,3029 ----
  2340.   
  2341.     bss_size = (bss_size + sizeof(double) - 1) & ~(sizeof(double)-1);
  2342.   
  2343. !   /* Give values to _end and friends.  */
  2344.     {
  2345. !     int end_value = data_start + data_size + bss_size;
  2346. !     if (end_symbol)
  2347. !       end_symbol->value = end_value;
  2348. !     if (end_symbol_alt)
  2349. !       end_symbol_alt->value = end_value;
  2350. !   }
  2351. ! 
  2352. !   {
  2353. !     int etext_value = text_size + text_start;
  2354. !     if (etext_symbol)
  2355. !       etext_symbol->value = etext_value;
  2356. !     if (etext_symbol_alt)
  2357. !       etext_symbol_alt->value = etext_value;
  2358. !   }
  2359. ! 
  2360. !   {
  2361. !     int edata_value = data_start + data_size;
  2362. !     if (edata_symbol)
  2363. !       edata_symbol->value = edata_value;
  2364. !     if (edata_symbol_alt)
  2365. !       edata_symbol_alt->value = edata_value;
  2366.     }
  2367.   
  2368.     /* Figure the data_pad now, so that it overlaps with the bss addresses.  */
  2369.   
  2370. +   {
  2371. +     /* The amount of data_pad that we are computing now.  This is the
  2372. +        part which overlaps with bss.  What was computed previously
  2373. +        goes before bss.  */
  2374. +     int data_pad_additional = 0;
  2375. +     
  2376.       if (specified_data_size && specified_data_size > data_size)
  2377. !       data_pad_additional = specified_data_size - data_size;
  2378.   
  2379. !     if (output_style == OUTPUT_DEMAND_PAGED)
  2380. !       data_pad_additional =
  2381. !     ((data_pad_additional + data_size + page_size - 1) & (- page_size)) - data_size;
  2382.   
  2383. !     bss_size -= data_pad_additional;
  2384.       if (bss_size < 0) bss_size = 0;
  2385.   
  2386. !     data_size += data_pad_additional;
  2387. ! 
  2388. !     data_pad += data_pad_additional;
  2389. !   }
  2390.   }
  2391.   
  2392.   /* Accumulate the section sizes of input file ENTRY
  2393. ***************
  2394. *** 2638,2651 ****
  2395.   
  2396.     entry->text_start_address = text_size;
  2397.     /* If there were any vectors, we need to chop them off */
  2398. !   text_size += entry->header.a_text;
  2399.     entry->data_start_address = data_size;
  2400. !   data_size += entry->header.a_data;
  2401.     entry->bss_start_address = bss_size;
  2402. !   bss_size += entry->header.a_bss;
  2403.   
  2404. !   text_reloc_size += entry->header.a_trsize;
  2405. !   data_reloc_size += entry->header.a_drsize;
  2406.   }
  2407.   
  2408.   /* Determine where the sections of ENTRY go into the output file,
  2409. --- 3038,3051 ----
  2410.   
  2411.     entry->text_start_address = text_size;
  2412.     /* If there were any vectors, we need to chop them off */
  2413. !   text_size += entry->text_size;
  2414.     entry->data_start_address = data_size;
  2415. !   data_size += entry->data_size;
  2416.     entry->bss_start_address = bss_size;
  2417. !   bss_size += entry->bss_size;
  2418.   
  2419. !   text_reloc_size += entry->text_reloc_size;
  2420. !   data_reloc_size += entry->data_reloc_size;
  2421.   }
  2422.   
  2423.   /* Determine where the sections of ENTRY go into the output file,
  2424. ***************
  2425. *** 2657,2665 ****
  2426.        register struct file_entry *entry;
  2427.   {
  2428.     entry->text_start_address += text_start;
  2429. !   /* Note that `data_start' and `data_size' have not yet been
  2430. !      adjusted for `data_pad'.  If they had been, we would get the wrong
  2431. !      results here.  */
  2432.     entry->data_start_address += data_start;
  2433.     entry->bss_start_address += data_start + data_size;
  2434.   
  2435. --- 3057,3066 ----
  2436.        register struct file_entry *entry;
  2437.   {
  2438.     entry->text_start_address += text_start;
  2439. ! 
  2440. !   /* Note that `data_start' and `data_size' have not yet been adjusted
  2441. !      for the portion of data_pad which overlaps with bss.  If they had
  2442. !      been, we would get the wrong results here.  */
  2443.     entry->data_start_address += data_start;
  2444.     entry->bss_start_address += data_start + data_size;
  2445.   
  2446. ***************
  2447. *** 2666,2697 ****
  2448.     {
  2449.       register struct nlist *p;
  2450.       register struct nlist *end
  2451. !       = entry->symbols + entry->header.a_syms / sizeof (struct nlist);
  2452.   
  2453.       for (p = entry->symbols; p < end; p++)
  2454.         {
  2455.       /* If this belongs to a section, update it by the section's start address */
  2456. !     register int type = p->n_type & N_TYPE;
  2457.   
  2458.       switch (type)
  2459.         {
  2460.         case N_TEXT:
  2461.         case N_SETT:
  2462. !         p->n_value += entry->text_start_address;
  2463.           break;
  2464.         case N_DATA:
  2465.         case N_SETV:
  2466.         case N_SETD:
  2467. !         /* A symbol whose value is in the data section
  2468. !            is present in the input file as if the data section
  2469. !            started at an address equal to the length of the file's text.  */
  2470. !         p->n_value += entry->data_start_address - entry->header.a_text;
  2471.           break;
  2472.         case N_BSS:
  2473.         case N_SETB:
  2474.           /* likewise for symbols with value in BSS.  */
  2475. !         p->n_value += entry->bss_start_address
  2476. !           - entry->header.a_text - entry->header.a_data;
  2477.           break;
  2478.         }
  2479.         }
  2480. --- 3067,3098 ----
  2481.     {
  2482.       register struct nlist *p;
  2483.       register struct nlist *end
  2484. !       = entry->symbols + entry->syms_size / sizeof (struct nlist);
  2485.   
  2486.       for (p = entry->symbols; p < end; p++)
  2487.         {
  2488.       /* If this belongs to a section, update it by the section's start address */
  2489. !     register int type = p->n_type & ~N_EXT;
  2490.   
  2491.       switch (type)
  2492.         {
  2493.         case N_TEXT:
  2494.         case N_SETT:
  2495. !         p->n_value += entry->text_start_address - entry->orig_text_address;
  2496.           break;
  2497.         case N_DATA:
  2498.         case N_SETV:
  2499.         case N_SETD:
  2500. !         /* Data segment symbol.  Subtract the address of the
  2501. !            data segment in the input file, and add the address
  2502. !            of this input file's data segment in the output file.  */
  2503. !         p->n_value +=
  2504. !           entry->data_start_address - entry->orig_data_address;
  2505.           break;
  2506.         case N_BSS:
  2507.         case N_SETB:
  2508.           /* likewise for symbols with value in BSS.  */
  2509. !         p->n_value += entry->bss_start_address - entry->orig_bss_address;
  2510.           break;
  2511.         }
  2512.         }
  2513. ***************
  2514. *** 2742,2750 ****
  2515.       fprintf (outfile, " symbols only\n", 0);
  2516.     else
  2517.       fprintf (outfile, " text %x(%x), data %x(%x), bss %x(%x) hex\n",
  2518. !          entry->text_start_address, entry->header.a_text,
  2519. !          entry->data_start_address, entry->header.a_data,
  2520. !          entry->bss_start_address, entry->header.a_bss);
  2521.   }
  2522.   
  2523.   void
  2524. --- 3143,3151 ----
  2525.       fprintf (outfile, " symbols only\n", 0);
  2526.     else
  2527.       fprintf (outfile, " text %x(%x), data %x(%x), bss %x(%x) hex\n",
  2528. !          entry->text_start_address, entry->text_size,
  2529. !          entry->data_start_address, entry->data_size,
  2530. !          entry->bss_start_address, entry->bss_size);
  2531.   }
  2532.   
  2533.   void
  2534. ***************
  2535. *** 2754,2762 ****
  2536.   {
  2537.     register struct nlist
  2538.       *p,
  2539. !     *end = entry->symbols + entry->header.a_syms / sizeof (struct nlist);
  2540.   
  2541. !   entry->strings = (char *) alloca (entry->string_size);
  2542.     read_entry_strings (file_open (entry), entry);
  2543.   
  2544.     fprintf (outfile, "\nLocal symbols of ");
  2545. --- 3155,3163 ----
  2546.   {
  2547.     register struct nlist
  2548.       *p,
  2549. !     *end = entry->symbols + entry->syms_size / sizeof (struct nlist);
  2550.   
  2551. !   entry->strings = (char *) alloca (entry->strs_size);
  2552.     read_entry_strings (file_open (entry), entry);
  2553.   
  2554.     fprintf (outfile, "\nLocal symbols of ");
  2555. ***************
  2556. *** 2831,2837 ****
  2557.     current->filename = next->filename;
  2558.   
  2559.     while (++(next->sym) < (entry->symbols
  2560. !               + entry->header.a_syms/sizeof (struct nlist)))
  2561.       {
  2562.         /* n_type is a char, and N_SOL, N_EINCL and N_BINCL are > 0x80, so
  2563.          * may look negative...therefore, must mask to low bits
  2564. --- 3232,3238 ----
  2565.     current->filename = next->filename;
  2566.   
  2567.     while (++(next->sym) < (entry->symbols
  2568. !               + entry->syms_size/sizeof (struct nlist)))
  2569.       {
  2570.         /* n_type is a char, and N_SOL, N_EINCL and N_BINCL are > 0x80, so
  2571.          * may look negative...therefore, must mask to low bits
  2572. ***************
  2573. *** 2891,2903 ****
  2574.   
  2575.     for (tmp = entry->symbols;
  2576.          tmp < (entry->symbols
  2577. !           + entry->header.a_syms/sizeof (struct nlist));
  2578.          tmp++)
  2579.       if (tmp->n_type == (int) N_SO)
  2580.         break;
  2581.   
  2582.     if (tmp >= (entry->symbols
  2583. !           + entry->header.a_syms/sizeof (struct nlist)))
  2584.       {
  2585.         /* I believe this translates to "We lose" */
  2586.         current->filename = next->filename = entry->filename;
  2587. --- 3292,3304 ----
  2588.   
  2589.     for (tmp = entry->symbols;
  2590.          tmp < (entry->symbols
  2591. !           + entry->syms_size/sizeof (struct nlist));
  2592.          tmp++)
  2593.       if (tmp->n_type == (int) N_SO)
  2594.         break;
  2595.   
  2596.     if (tmp >= (entry->symbols
  2597. !           + entry->syms_size/sizeof (struct nlist)))
  2598.       {
  2599.         /* I believe this translates to "We lose" */
  2600.         current->filename = next->filename = entry->filename;
  2601. ***************
  2602. *** 2955,2961 ****
  2603.     int use_data_symbols;
  2604.   
  2605.     if (next->sym)
  2606. !     use_data_symbols = (next->sym->n_type & N_TYPE) == N_DATA;
  2607.     else
  2608.       return current->line;
  2609.   
  2610. --- 3356,3362 ----
  2611.     int use_data_symbols;
  2612.   
  2613.     if (next->sym)
  2614. !     use_data_symbols = (next->sym->n_type & ~N_EXT) == N_DATA;
  2615.     else
  2616.       return current->line;
  2617.   
  2618. ***************
  2619. *** 3007,3013 ****
  2620.       *reloc_start = data_segment ? entry->datarel : entry->textrel,
  2621.       *reloc;
  2622.     int reloc_size
  2623. !     = ((data_segment ? entry->header.a_drsize : entry->header.a_trsize)
  2624.          / sizeof (struct relocation_info));
  2625.     int start_of_segment
  2626.       = (data_segment ? entry->data_start_address : entry->text_start_address);
  2627. --- 3408,3414 ----
  2628.       *reloc_start = data_segment ? entry->datarel : entry->textrel,
  2629.       *reloc;
  2630.     int reloc_size
  2631. !     = ((data_segment ? entry->data_reloc_size : entry->text_reloc_size)
  2632.          / sizeof (struct relocation_info));
  2633.     int start_of_segment
  2634.       = (data_segment ? entry->data_start_address : entry->text_start_address);
  2635. ***************
  2636. *** 3014,3023 ****
  2637.     struct nlist *start_of_syms = entry->symbols;
  2638.     struct line_debug_entry *state_pointer
  2639.       = init_debug_scan (data_segment != 0, entry);
  2640. !   register struct line_debug_entry
  2641. !     *current = state_pointer,
  2642. !     *next = state_pointer + 1,
  2643. !     *source = state_pointer + 2;
  2644.     /* Assigned to generally static values; should not be written into.  */
  2645.     char *errfmt;
  2646.     /* Assigned to alloca'd values cand copied into; should be freed
  2647. --- 3415,3421 ----
  2648.     struct nlist *start_of_syms = entry->symbols;
  2649.     struct line_debug_entry *state_pointer
  2650.       = init_debug_scan (data_segment != 0, entry);
  2651. !   register struct line_debug_entry *current = state_pointer;
  2652.     /* Assigned to generally static values; should not be written into.  */
  2653.     char *errfmt;
  2654.     /* Assigned to alloca'd values cand copied into; should be freed
  2655. ***************
  2656. *** 3095,3102 ****
  2657.         /* If errfmt == 0, errmsg has already been defined.  */
  2658.         if (errfmt != 0)
  2659.       {
  2660. !       errmsg = (char *) xmalloc (strlen (errfmt) + strlen (g->name) + 1);
  2661. !       sprintf (errmsg, errfmt, g->name, data_segment ? "data" : "text");
  2662.       }
  2663.   
  2664.         address_to_line (RELOC_ADDRESS (reloc) + start_of_segment,
  2665. --- 3493,3506 ----
  2666.         /* If errfmt == 0, errmsg has already been defined.  */
  2667.         if (errfmt != 0)
  2668.       {
  2669. !       char *nm;
  2670. ! 
  2671. !       if (!demangler || !(nm = (*demangler)(g->name)))
  2672. !         nm = g->name;
  2673. !       errmsg = xmalloc (strlen (errfmt) + strlen (nm) + 1);
  2674. !       sprintf (errmsg, errfmt, nm, data_segment ? "data" : "text");
  2675. !       if (nm != g->name)
  2676. !         free (nm);
  2677.       }
  2678.   
  2679.         address_to_line (RELOC_ADDRESS (reloc) + start_of_segment,
  2680. ***************
  2681. *** 3103,3112 ****
  2682.                  state_pointer);
  2683.   
  2684.         if (current->line >=0)
  2685. !     fprintf (outfile, "%s:%d: %s\n", current->filename,
  2686. !          invalidate_line_number ? 0 : current->line, errmsg);
  2687.         else
  2688. !     fprintf (outfile, "%s: %s\n", current->filename, errmsg);
  2689.   
  2690.         if (errfmt != 0)
  2691.       free (errmsg);
  2692. --- 3507,3523 ----
  2693.                  state_pointer);
  2694.   
  2695.         if (current->line >=0)
  2696. !     {
  2697. !       fprintf (outfile, "%s:%d (", current->filename,
  2698. !            invalidate_line_number ? 0 : current->line);
  2699. !       print_file_name (entry, outfile);
  2700. !       fprintf (outfile, "): %s\n", errmsg);
  2701. !     }
  2702.         else
  2703. !     {
  2704. !       print_file_name(entry, outfile);
  2705. !       fprintf(outfile, ": %s\n", errmsg);
  2706. !     }
  2707.   
  2708.         if (errfmt != 0)
  2709.       free (errmsg);
  2710. ***************
  2711. *** 3124,3130 ****
  2712.        struct file_entry *entry;
  2713.        FILE *outfile;
  2714.   {
  2715. !   int number_of_syms = entry->header.a_syms / sizeof (struct nlist);
  2716.     unsigned char *nlist_bitvector
  2717.       = (unsigned char *) alloca ((number_of_syms >> 3) + 1);
  2718.     struct line_debug_entry *text_scan, *data_scan;
  2719. --- 3535,3541 ----
  2720.        struct file_entry *entry;
  2721.        FILE *outfile;
  2722.   {
  2723. !   int number_of_syms = entry->syms_size / sizeof (struct nlist);
  2724.     unsigned char *nlist_bitvector
  2725.       = (unsigned char *) alloca ((number_of_syms >> 3) + 1);
  2726.     struct line_debug_entry *text_scan, *data_scan;
  2727. ***************
  2728. *** 3140,3146 ****
  2729.       {
  2730.         int desc;
  2731.   
  2732. !       entry->strings = (char *) alloca (entry->string_size);
  2733.         desc = file_open (entry);
  2734.         read_entry_strings (desc, entry);
  2735.       }
  2736. --- 3551,3557 ----
  2737.       {
  2738.         int desc;
  2739.   
  2740. !       entry->strings = (char *) alloca (entry->strs_size);
  2741.         desc = file_open (entry);
  2742.         read_entry_strings (desc, entry);
  2743.       }
  2744. ***************
  2745. *** 3229,3242 ****
  2746.       continue;
  2747.         
  2748.         if (line_number == -1)
  2749. !     fprintf (outfile, "%s: ", entry->filename);
  2750.         else
  2751. !     fprintf (outfile, "%s:%d: ", file_name, line_number);
  2752.   
  2753.         if (dont_allow_symbol_name)
  2754.       fprintf (outfile, "%s", errfmt);
  2755.         else
  2756.       fprintf (outfile, errfmt, g->name);
  2757.   
  2758.         fputc ('\n', outfile);
  2759.       }
  2760. --- 3640,3670 ----
  2761.       continue;
  2762.   
  2763.         if (line_number == -1)
  2764. !     {
  2765. !       print_file_name (entry, outfile);
  2766. !       fprintf (outfile, ": ");
  2767. !     }
  2768.         else
  2769. !     {
  2770. !       fprintf (outfile, "%s:%d (", file_name, line_number);
  2771. !       print_file_name (entry, outfile);
  2772. !       fprintf (outfile, "): ");
  2773. !     }
  2774.   
  2775.         if (dont_allow_symbol_name)
  2776.       fprintf (outfile, "%s", errfmt);
  2777.         else
  2778. +     {
  2779. +       char *nm;
  2780. + 
  2781. +       if (!demangler || !(nm = (*demangler)(g->name)))
  2782.           fprintf (outfile, errfmt, g->name);
  2783. +       else
  2784. +         {
  2785. +           fprintf (outfile, errfmt, nm);
  2786. +           free (nm);
  2787. +         }
  2788. +     }
  2789.   
  2790.         fputc ('\n', outfile);
  2791.       }
  2792. ***************
  2793. *** 3248,3256 ****
  2794.   do_warnings (outfile)
  2795.        FILE *outfile;
  2796.   {
  2797. !   int i;
  2798. ! 
  2799. !   list_unresolved_refs = !relocatable_output && undefined_global_sym_count;
  2800.     list_warning_symbols = warning_count;
  2801.     list_multiple_defs = multiple_def_count != 0;
  2802.   
  2803. --- 3676,3682 ----
  2804.   do_warnings (outfile)
  2805.        FILE *outfile;
  2806.   {
  2807. !   list_unresolved_refs = output_style != OUTPUT_RELOCATABLE && undefined_global_sym_count;
  2808.     list_warning_symbols = warning_count;
  2809.     list_multiple_defs = multiple_def_count != 0;
  2810.   
  2811. ***************
  2812. *** 3266,3326 ****
  2813.       make_executable = 0;
  2814.   }
  2815.   
  2816. ! /* Write the output file */
  2817. ! 
  2818. ! void
  2819. ! write_output ()
  2820. ! {
  2821. !   struct stat statbuf;
  2822. !   int filemode;
  2823. ! 
  2824. !   outdesc = open (output_filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
  2825. !   if (outdesc < 0) perror_name (output_filename);
  2826.   
  2827. !   if (fstat (outdesc, &statbuf) < 0)
  2828. !     perror_name (output_filename);
  2829.   
  2830. !   filemode = statbuf.st_mode;
  2831.   
  2832. !   chmod (output_filename, filemode & ~0111);
  2833.   
  2834. !   /* Output the a.out header.  */
  2835. !   write_header ();
  2836.   
  2837. !   /* Output the text and data segments, relocating as we go.  */
  2838. !   write_text ();
  2839. !   write_data ();
  2840.   
  2841. !   /* Output the merged relocation info, if requested with `-r'.  */
  2842. !   if (relocatable_output)
  2843. !     write_rel ();
  2844.   
  2845. !   /* Output the symbol table (both globals and locals).  */
  2846. !   write_syms ();
  2847.   
  2848. !   /* Copy any GDB symbol segments from input files.  */
  2849. !   write_symsegs ();
  2850.   
  2851. !   close (outdesc);
  2852.   
  2853. !   if (chmod (output_filename, filemode | 0111) == -1)
  2854. !     perror_name (output_filename);
  2855.   }
  2856. ! 
  2857. ! void modify_location (), perform_relocation (), copy_text (), copy_data ();
  2858.   
  2859.   void
  2860. ! write_header ()
  2861.   {
  2862. -   N_SET_MAGIC (outheader, magic);
  2863.     outheader.a_text = text_size;
  2864.   #ifdef sequent
  2865.     outheader.a_text += N_ADDRADJ (outheader);
  2866.   #endif
  2867.     outheader.a_data = data_size;
  2868.     outheader.a_bss = bss_size;
  2869.     outheader.a_entry = (entry_symbol ? entry_symbol->value
  2870. !                : text_start + entry_offset);
  2871.   #ifdef COFF_ENCAPSULATE
  2872.     if (need_coff_header)
  2873.       {
  2874. --- 3692,3795 ----
  2875.       make_executable = 0;
  2876.   }
  2877.   
  2878. ! #ifdef A_OUT
  2879.   
  2880. ! /* Stuff pertaining to creating a.out files. */
  2881.   
  2882. ! /* The a.out header. */
  2883.   
  2884. ! struct exec outheader;
  2885.   
  2886. ! #ifdef COFF_ENCAPSULATE
  2887. ! int need_coff_header;
  2888. ! struct coffheader coffheader;
  2889. ! #endif
  2890.   
  2891. ! /* Compute text_start and text_header_size for an a.out file.  */
  2892.   
  2893. ! void
  2894. ! initialize_a_out_text_start ()
  2895. ! {
  2896. !   int magic;
  2897.   
  2898. !   switch (output_style)
  2899. !     {
  2900. !     case OUTPUT_RELOCATABLE:
  2901. !     case OUTPUT_WRITABLE_TEXT:
  2902. !       magic = OMAGIC;
  2903. !       break;
  2904. !     case OUTPUT_READONLY_TEXT:
  2905. ! #ifdef NMAGIC
  2906. !       magic = NMAGIC;
  2907. !       break;
  2908. ! #endif
  2909. !     case OUTPUT_DEMAND_PAGED:
  2910. !       magic = ZMAGIC;
  2911. !       break;
  2912. !     default:
  2913. !       fatal ("unknown output style found (bug in ld)", (char *) 0);
  2914. !       break;
  2915. !     }
  2916.   
  2917. !   /* Determine whether to count the header as part of
  2918. !      the text size, and initialize the text size accordingly.
  2919. !      This depends on the kind of system and on the output format selected.  */
  2920. !   N_SET_MAGIC (outheader, magic);
  2921. ! #ifdef INITIALIZE_HEADER
  2922. !   INITIALIZE_HEADER;
  2923. ! #endif
  2924.   
  2925. !   text_header_size = sizeof (struct exec);
  2926. ! #ifdef COFF_ENCAPSULATE
  2927. !   /* Don't write the coff header for the output of ld -A (since
  2928. !      it is not executable by the kernel anyway).  */
  2929. !   if (output_style != OUTPUT_RELOCATABLE && !file_table[0].just_syms_flag)
  2930. !     {
  2931. !       need_coff_header = 1;
  2932. !       /* set this flag now, since it will change the values of N_TXTOFF, etc */
  2933. !       N_SET_FLAGS (outheader, N_FLAGS_COFF_ENCAPSULATE);
  2934. !       text_header_size += sizeof (struct coffheader);
  2935. !     }
  2936. ! #endif
  2937. !   if (text_header_size <= N_TXTOFF (outheader))
  2938. !     text_header_size = 0;
  2939. !   else
  2940. !     text_header_size -= N_TXTOFF (outheader);
  2941. ! 
  2942. ! #ifdef _N_BASEADDR
  2943. !   /* SunOS 4.1 N_TXTADDR depends on the value of outheader.a_entry. */
  2944. !   outheader.a_entry = N_PAGSIZ(outheader);
  2945. ! #endif
  2946.   
  2947. !   if (!T_flag_specified && output_style != OUTPUT_RELOCATABLE)
  2948. !     text_start = N_TXTADDR (outheader);
  2949.   }
  2950. ! 
  2951. ! /* Compute data_start once text_size is known. */
  2952.   
  2953.   void
  2954. ! initialize_a_out_data_start ()
  2955.   {
  2956.     outheader.a_text = text_size;
  2957.   #ifdef sequent
  2958.     outheader.a_text += N_ADDRADJ (outheader);
  2959. +   if (entry_symbol == 0)
  2960. +     entry_symbol = getsym ("start");
  2961.   #endif
  2962. +   if (! Tdata_flag_specified)
  2963. +     data_start = N_DATADDR (outheader) + text_start - N_TXTADDR (outheader);
  2964. + }
  2965. + 
  2966. + /* Compute offsets of various pieces of the a.out output file.  */
  2967. + 
  2968. + void
  2969. + compute_a_out_section_offsets ()
  2970. + {
  2971.     outheader.a_data = data_size;
  2972.     outheader.a_bss = bss_size;
  2973.     outheader.a_entry = (entry_symbol ? entry_symbol->value
  2974. !                : text_start + text_header_size);
  2975. ! 
  2976.   #ifdef COFF_ENCAPSULATE
  2977.     if (need_coff_header)
  2978.       {
  2979. ***************
  2980. *** 3384,3393 ****
  2981.       }
  2982.   #endif
  2983.   
  2984. - #ifdef INITIALIZE_HEADER
  2985. -   INITIALIZE_HEADER;
  2986. - #endif
  2987. - 
  2988.     if (strip_symbols == STRIP_ALL)
  2989.       nsyms = 0;
  2990.     else
  2991. --- 3853,3858 ----
  2992. ***************
  2993. *** 3399,3406 ****
  2994.         else if (discard_locals == DISCARD_NONE)
  2995.       nsyms += local_sym_count;
  2996.         /* One extra for following reference on indirects */
  2997. !       if (relocatable_output)
  2998.       nsyms += set_symbol_count + global_indirect_count;
  2999.       }
  3000.   
  3001.     if (strip_symbols == STRIP_NONE)
  3002. --- 3864,3875 ----
  3003.         else if (discard_locals == DISCARD_NONE)
  3004.       nsyms += local_sym_count;
  3005.         /* One extra for following reference on indirects */
  3006. !       if (output_style == OUTPUT_RELOCATABLE)
  3007. ! #ifndef NeXT
  3008.       nsyms += set_symbol_count + global_indirect_count;
  3009. + #else
  3010. +         nsyms += set_symbol_count;
  3011. + #endif
  3012.       }
  3013.   
  3014.     if (strip_symbols == STRIP_NONE)
  3015. ***************
  3016. *** 3408,3414 ****
  3017.   
  3018.     outheader.a_syms = nsyms * sizeof (struct nlist);
  3019.   
  3020. !   if (relocatable_output)
  3021.       {
  3022.         outheader.a_trsize = text_reloc_size;
  3023.         outheader.a_drsize = data_reloc_size;
  3024. --- 3877,3883 ----
  3025.   
  3026.     outheader.a_syms = nsyms * sizeof (struct nlist);
  3027.   
  3028. !   if (output_style == OUTPUT_RELOCATABLE)
  3029.       {
  3030.         outheader.a_trsize = text_reloc_size;
  3031.         outheader.a_drsize = data_reloc_size;
  3032. ***************
  3033. *** 3419,3428 ****
  3034. --- 3888,3935 ----
  3035.         outheader.a_drsize = 0;
  3036.       }
  3037.   
  3038. +   /* Initialize the various file offsets.  */
  3039. + 
  3040. +   output_text_offset = N_TXTOFF (outheader);
  3041. + #ifdef N_DATOFF
  3042. +   output_data_offset = N_DATOFF (outheader);
  3043. + #else
  3044. +   output_data_offset = output_text_offset + text_size;
  3045. + #endif
  3046. + #ifdef N_TRELOFF
  3047. +   output_trel_offset = N_TRELOFF (outheader);
  3048. + #else
  3049. +   output_trel_offset = output_data_offset + data_size;
  3050. + #endif
  3051. + #ifdef N_DRELOFF
  3052. +   output_drel_offset = N_DRELOFF (outheader);
  3053. + #else
  3054. +   output_drel_offset = output_trel_offset + text_reloc_size;
  3055. + #endif
  3056. +   output_syms_offset = N_SYMOFF (outheader);
  3057. +   output_strs_offset = N_STROFF (outheader);
  3058. + }
  3059. + 
  3060. + /* Compute more section offsets once the size of the string table is known.  */
  3061. + 
  3062. + void
  3063. + compute_more_a_out_section_offsets ()
  3064. + {
  3065. +   output_symseg_offset = output_strs_offset + output_strs_size;
  3066. + }
  3067. + 
  3068. + /* Write the a.out header once everything else is known.  */
  3069. + 
  3070. + void
  3071. + write_a_out_header ()
  3072. + {
  3073. +   lseek (outdesc, 0L, 0);
  3074. + 
  3075.   #ifdef COFF_ENCAPSULATE
  3076.     if (need_coff_header)
  3077.       mywrite (&coffheader, sizeof coffheader, 1, outdesc);
  3078.   #endif
  3079. + 
  3080.     mywrite (&outheader, sizeof (struct exec), 1, outdesc);
  3081.   
  3082.     /* Output whatever padding is required in the executable file
  3083. ***************
  3084. *** 3432,3438 ****
  3085. --- 3939,4570 ----
  3086.     padfile (N_TXTOFF (outheader) - sizeof outheader, outdesc);
  3087.   #endif
  3088.   }
  3089. + 
  3090. + #endif
  3091. + 
  3092. + #ifdef MACH_O
  3093. + 
  3094. + /* Stuff pertaining to creating Mach-O files. */
  3095. + 
  3096. + /* Convert the Mach-O style n_sect references into something the rest
  3097. +    of the loader can understand.  */
  3098. + 
  3099. + void
  3100. + translate_mach_o_symbols (entry)
  3101. +      struct file_entry *entry;
  3102. + {
  3103. +   int i, n, g;
  3104. +   struct nlist *sym;
  3105. + 
  3106. +   n = entry->syms_size / sizeof (struct nlist);
  3107. +   for (i = 0; i < n; ++i)
  3108. +     if (((sym = &entry->symbols[i])->n_type & ~N_EXT) == N_SECT)
  3109. +       {
  3110. +     if (sym->n_sect == entry->text_ordinal)
  3111. +       sym->n_type = (sym->n_type & N_EXT) | N_TEXT;
  3112. +     else if (sym->n_sect == entry->data_ordinal)
  3113. +       sym->n_type = (sym->n_type & N_EXT) | N_DATA;
  3114. +     else if (sym->n_sect == entry->bss_ordinal)
  3115. +       sym->n_type = (sym->n_type & N_EXT) | N_BSS;
  3116. +     else
  3117. +       fatal_with_file ("unknown section referenced in symbols of ", entry);
  3118. +     sym->n_sect = 0;
  3119. +       }
  3120. +     else if ((sym = &entry->symbols[i])->n_type == N_SLINE)
  3121. +       {
  3122. +     if (sym->n_sect == entry->text_ordinal)
  3123. +       sym->n_type = N_SLINE;
  3124. +     else if (sym->n_sect == entry->data_ordinal)
  3125. +       sym->n_type = N_DSLINE;
  3126. +     else if (sym->n_sect == entry->bss_ordinal)
  3127. +       sym->n_type = N_BSLINE;
  3128. +     else
  3129. +       fatal_with_file ("unknown section referenced in debugging symbols of ", entry);
  3130. +       }
  3131. + }
  3132. + 
  3133. + /* Convert Mach-O style relocation info into a.out style relocation
  3134. +    info internally.  */
  3135. + void
  3136. + translate_mach_o_relocation (entry, reloc, count)
  3137. +      struct file_entry *entry;
  3138. +      struct relocation_info *reloc;
  3139. +      int count;
  3140. + {
  3141. +   int i;
  3142. + 
  3143. +   for (i = 0; i < count; ++i)
  3144. +     if (!RELOC_EXTERN_P(&reloc[i]))
  3145. +       if (RELOC_TYPE(&reloc[i]) == R_ABS)
  3146. +     RELOC_TYPE(&reloc[i]) = N_ABS;
  3147. +       else if (RELOC_TYPE(&reloc[i]) == entry->text_ordinal)
  3148. +     RELOC_TYPE(&reloc[i]) = N_TEXT;
  3149. +       else if (RELOC_TYPE(&reloc[i]) == entry->data_ordinal)
  3150. +     RELOC_TYPE(&reloc[i]) = N_DATA;
  3151. +       else if (RELOC_TYPE(&reloc[i]) == entry->bss_ordinal)
  3152. +     RELOC_TYPE(&reloc[i]) = N_BSS;
  3153. +       else
  3154. +     fatal_with_file ("unknown section ordinal in relocation info of ", entry);
  3155. + }
  3156. + 
  3157. + /* Header structure for OUTPUT_RELOCATABLE.  */
  3158. + 
  3159. + struct
  3160. + {
  3161. +   struct mach_header header;
  3162. +   struct segment_command segment;
  3163. +   struct section text;
  3164. +   struct section data;
  3165. +   struct section bss;
  3166. +   struct symtab_command symtab;
  3167. + #ifdef LC_SYMSEG
  3168. +   struct symseg_command symseg;
  3169. + #endif
  3170. + } m_object;
  3171. + 
  3172. + #ifdef NeXT
  3173. + #define CPU_TYPE CPU_TYPE_MC68030
  3174. + #define CPU_SUBTYPE CPU_SUBTYPE_NeXT
  3175. + #define THREAD_FLAVOR NeXT_THREAD_STATE_REGS
  3176. + #define THREAD_COUNT NeXT_THREAD_STATE_REGS_COUNT
  3177. + typedef struct NeXT_thread_state_regs thread_state;
  3178. + #define thread_state_entry_field pc
  3179. + #endif
  3180. + 
  3181. + /* Header structure for all executable output forms.  */
  3182. + 
  3183. + struct
  3184. + {
  3185. +   struct mach_header header;
  3186. +   struct segment_command pagezero;
  3187. +   struct segment_command text_segment;
  3188. +   struct section text;
  3189. +   struct segment_command data_segment;
  3190. +   struct section data;
  3191. +   struct section bss;
  3192. +   struct thread_command unixthread;
  3193. +   unsigned long int flavor;
  3194. +   unsigned long int count;
  3195. +   thread_state state;
  3196. +   struct symtab_command symtab;
  3197. + #ifdef LC_SYMSEG
  3198. +   struct symseg_command symseg;
  3199. + #endif
  3200. + } m_exec;
  3201. + 
  3202. + /* Compute text_start and text_header_size for an a.out file.  */
  3203. + 
  3204. + void
  3205. + initialize_mach_o_text_start ()
  3206. + {
  3207. +   if (output_style != OUTPUT_RELOCATABLE)
  3208. +     {
  3209. +       text_header_size = sizeof m_exec;
  3210. +       if (!T_flag_specified && output_style != OUTPUT_RELOCATABLE)
  3211. +     /* We reserve the first page of an executable to trap NULL dereferences.  */
  3212. +     text_start = page_size;
  3213. +     }
  3214. + }
  3215. + 
  3216. + /* Compute data_start once text_size is known.  */
  3217. + 
  3218. + void
  3219. + initialize_mach_o_data_start ()
  3220. + {
  3221. +   if (! Tdata_flag_specified)
  3222. +     data_start = text_start + text_size;
  3223. + }
  3224. + 
  3225. + /* Compute offsets of various pieces of the Mach-O output file.  */
  3226. + void
  3227. + compute_mach_o_section_offsets ()
  3228. + {
  3229. +   int header_size, trsize, drsize;
  3230. + 
  3231. +   switch (output_style)
  3232. +     {
  3233. +     case OUTPUT_RELOCATABLE:
  3234. +       header_size = sizeof m_object;
  3235. +       break;
  3236. +     default:
  3237. +       header_size = sizeof m_exec;
  3238. +       break;
  3239. +     }
  3240. + 
  3241. +   if (strip_symbols == STRIP_ALL)
  3242. +     nsyms = 0;
  3243. +   else
  3244. +     {
  3245. +       nsyms = (defined_global_sym_count
  3246. +            + undefined_global_sym_count);
  3247. +       if (discard_locals == DISCARD_L)
  3248. +     nsyms += non_L_local_sym_count;
  3249. +       else if (discard_locals == DISCARD_NONE)
  3250. +     nsyms += local_sym_count;
  3251. +       /* One extra for following reference on indirects */
  3252. +       if (output_style == OUTPUT_RELOCATABLE)
  3253. + #ifndef NeXT
  3254. +     nsyms += set_symbol_count + global_indirect_count;
  3255. + #else
  3256. +         nsyms += set_symbol_count;
  3257. + #endif
  3258. +     }
  3259. + 
  3260. +   if (strip_symbols == STRIP_NONE)
  3261. +     nsyms += debugger_sym_count;
  3262. + 
  3263. +   if (output_style != OUTPUT_RELOCATABLE)
  3264. +     output_text_offset = header_size;
  3265. +   output_data_offset = output_text_offset + text_size;
  3266. +   output_trel_offset = output_data_offset + data_size;
  3267. +   if (output_style == OUTPUT_RELOCATABLE)
  3268. +     trsize = text_reloc_size, drsize = data_reloc_size;
  3269. +   else
  3270. +     trsize = drsize = 0;
  3271. +   output_drel_offset = output_trel_offset + trsize;
  3272. +   output_syms_offset = output_drel_offset + drsize;
  3273. +   output_strs_offset = output_syms_offset + nsyms * sizeof (struct nlist);
  3274. + }
  3275. + 
  3276. + /* Compute more section offsets once the size of the string table is known.  */
  3277. + void
  3278. + compute_more_mach_o_section_offsets ()
  3279. + {
  3280. +   output_symseg_offset = output_strs_offset + output_strs_size;
  3281. + }
  3282. + 
  3283. + /* Write the Mach-O header once everything else is known.  */
  3284. + 
  3285. + void
  3286. + write_mach_o_header ()
  3287. + {
  3288. +   struct mach_header header;
  3289. +   struct section text, data, bss;
  3290. +   struct symtab_command symtab;
  3291. + #ifdef LC_SYMSEG
  3292. +   struct symseg_command symseg;
  3293. + #endif
  3294. +   thread_state state;
  3295. + 
  3296. +   lseek (outdesc, 0L, 0);
  3297. + 
  3298. + 
  3299. +   header.magic = MH_MAGIC;
  3300. +   header.cputype = CPU_TYPE;
  3301. +   header.cpusubtype = CPU_SUBTYPE;
  3302. +   header.filetype = output_style == OUTPUT_RELOCATABLE ? MH_OBJECT : MH_EXECUTE;
  3303. + #ifdef LC_SYMSEG
  3304. +   switch (output_style)
  3305. +     {
  3306. +     case OUTPUT_RELOCATABLE:
  3307. +       header.ncmds = 3;
  3308. +       header.sizeofcmds = sizeof m_object - sizeof header;
  3309. +       break;
  3310. +     default:
  3311. +       header.ncmds = 6;
  3312. +       header.sizeofcmds = sizeof m_exec - sizeof header;
  3313. +       break;
  3314. +     }
  3315. + #else
  3316. +   switch (output_style)
  3317. +     {
  3318. +     case OUTPUT_RELOCATABLE:
  3319. +       header.ncmds = 2;
  3320. +       header.sizeofcmds = sizeof m_object - sizeof header;
  3321. +       break;
  3322. +     default:
  3323. +       header.ncmds = 5;
  3324. +       header.sizeofcmds = sizeof m_exec - sizeof header;
  3325. +       break;
  3326. +     }
  3327. + #endif
  3328. +   header.flags = undefined_global_sym_count ? 0 : MH_NOUNDEFS;
  3329. + 
  3330. +   bzero((char *) &text, sizeof text);
  3331. +   strncpy(text.sectname, SECT_TEXT, sizeof text.sectname);
  3332. +   strncpy(text.segname, SEG_TEXT, sizeof text.segname);
  3333. +   text.addr = text_start;
  3334. +   text.size = text_size;
  3335. +   text.offset = output_text_offset;
  3336. +   text.align = text.addr % sizeof (double) ? sizeof (int) : sizeof (double);
  3337. +   text.reloff = output_trel_offset;
  3338. +   text.nreloc = output_style == OUTPUT_RELOCATABLE
  3339. +     ? text_reloc_size / sizeof (struct relocation_info) : 0;
  3340. +   text.flags = 0;
  3341. + 
  3342. +   bzero((char *) &data, sizeof data);
  3343. +   strncpy(data.sectname, SECT_DATA, sizeof data.sectname);
  3344. +   strncpy(data.segname, output_style == OUTPUT_WRITABLE_TEXT ? SEG_TEXT : SEG_DATA,
  3345. +       sizeof data.segname);
  3346. +   data.addr = data_start;
  3347. +   data.size = data_size;
  3348. +   data.offset = output_data_offset;
  3349. +   data.align = data.addr % sizeof (double) ? sizeof (int) : sizeof (double);
  3350. +   data.reloff = output_drel_offset;
  3351. +   data.nreloc = output_style == OUTPUT_RELOCATABLE
  3352. +     ? data_reloc_size / sizeof (struct relocation_info) : 0;
  3353. +   data.flags = 0;
  3354. + 
  3355. +   bzero((char *) &bss, sizeof bss);
  3356. +   strncpy(bss.sectname, SECT_BSS, sizeof data.sectname);
  3357. +   strncpy(bss.segname, output_style == OUTPUT_WRITABLE_TEXT ? SEG_TEXT : SEG_DATA,
  3358. +       sizeof bss.segname);
  3359. +   bss.addr = data_start + data_size;
  3360. +   bss.size = bss_size;
  3361. +   bss.align = bss.addr % sizeof (double) ? sizeof (int) : sizeof (double);
  3362. +   bss.reloff = 0;
  3363. +   bss.nreloc = 0;
  3364. +   bss.flags = S_ZEROFILL;
  3365. + 
  3366. +   symtab.cmd = LC_SYMTAB;
  3367. +   symtab.cmdsize = sizeof symtab;
  3368. +   symtab.symoff = output_syms_offset;
  3369. +   symtab.nsyms = output_syms_size / sizeof (struct nlist);
  3370. +   symtab.stroff = output_strs_offset;
  3371. +   symtab.strsize = output_strs_size;
  3372. + 
  3373. + #ifdef LC_SYMSEG
  3374. +   symseg.cmd = LC_SYMSEG;
  3375. +   symseg.cmdsize = sizeof symseg;
  3376. +   symseg.offset = output_symseg_offset;
  3377. +   symseg.size = output_symseg_size;
  3378. + #endif
  3379. + 
  3380. +   switch (output_style)
  3381. +     {
  3382. +     case OUTPUT_RELOCATABLE:
  3383. +       m_object.header = header;
  3384. +       m_object.segment.cmd = LC_SEGMENT;
  3385. +       m_object.segment.cmdsize = sizeof (struct segment_command) + 3 * sizeof (struct section);
  3386. +       strncpy(m_object.segment.segname, SEG_TEXT, sizeof m_object.segment.segname);
  3387. +       m_object.segment.vmaddr = 0;
  3388. +       m_object.segment.vmsize = text.size + data.size + bss.size;
  3389. +       m_object.segment.fileoff = text.offset;
  3390. +       m_object.segment.filesize = text.size + data.size;
  3391. +       m_object.segment.maxprot = VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE;
  3392. +       m_object.segment.initprot = VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE;
  3393. +       m_object.segment.nsects = 3;
  3394. +       m_object.segment.flags = 0;
  3395. +       m_object.text = text;
  3396. +       m_object.data = data;
  3397. +       m_object.bss = bss;
  3398. +       m_object.symtab = symtab;
  3399. + #ifdef LC_SYMSEG
  3400. +       m_object.symseg = symseg;
  3401. + #endif
  3402. +       mywrite((char *) &m_object, 1, sizeof m_object, outdesc);
  3403. +       break;
  3404. + 
  3405. +     default:
  3406. +       m_exec.header = header;
  3407. +       m_exec.pagezero.cmd = LC_SEGMENT;
  3408. +       m_exec.pagezero.cmdsize = sizeof (struct segment_command);
  3409. +       strncpy(m_exec.pagezero.segname, SEG_PAGEZERO, sizeof m_exec.pagezero.segname);
  3410. +       m_exec.pagezero.vmaddr = 0;
  3411. +       m_exec.pagezero.vmsize = page_size;
  3412. +       m_exec.pagezero.fileoff = 0;
  3413. +       m_exec.pagezero.filesize = 0;
  3414. +       m_exec.pagezero.maxprot = VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE;
  3415. +       m_exec.pagezero.initprot = 0;
  3416. +       m_exec.pagezero.nsects = 0;
  3417. +       m_exec.pagezero.flags = 0;
  3418. +       m_exec.text_segment.cmd = LC_SEGMENT;
  3419. +       m_exec.text_segment.cmdsize = sizeof (struct segment_command) + sizeof (struct section);
  3420. +       strncpy(m_exec.text_segment.segname, SEG_TEXT, sizeof m_exec.text_segment.segname);
  3421. +       m_exec.text_segment.vmaddr = text_start;
  3422. +       m_exec.text_segment.vmsize = text_size;
  3423. +       m_exec.text_segment.fileoff = output_text_offset;
  3424. +       m_exec.text_segment.filesize = text_size;
  3425. +       m_exec.text_segment.maxprot = VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE;
  3426. +       m_exec.text_segment.initprot = VM_PROT_READ | VM_PROT_EXECUTE;
  3427. +       if (output_style == OUTPUT_WRITABLE_TEXT)
  3428. +     m_exec.text_segment.initprot |= VM_PROT_WRITE;
  3429. +       m_exec.text_segment.nsects = 1;
  3430. +       m_exec.text_segment.flags = 0;
  3431. +       m_exec.text = text;
  3432. +       m_exec.data_segment.cmd = LC_SEGMENT;
  3433. +       m_exec.data_segment.cmdsize = sizeof (struct segment_command) + 2 * sizeof (struct section);
  3434. +       strncpy(m_exec.data_segment.segname, SEG_DATA, sizeof m_exec.data_segment.segname);
  3435. +       m_exec.data_segment.vmaddr = data_start;
  3436. +       m_exec.data_segment.vmsize = data_size + bss_size;
  3437. +       m_exec.data_segment.fileoff = output_data_offset;
  3438. +       m_exec.data_segment.filesize = data_size;
  3439. +       m_exec.data_segment.maxprot = VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE;
  3440. +       m_exec.data_segment.initprot = VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE;
  3441. +       m_exec.data_segment.nsects = 2;
  3442. +       m_exec.data_segment.flags = 0;
  3443. +       m_exec.data = data;
  3444. +       m_exec.bss = bss;
  3445. +       m_exec.unixthread.cmd = LC_UNIXTHREAD;
  3446. +       m_exec.unixthread.cmdsize
  3447. +     = sizeof (struct thread_command) + 2 * sizeof (long int) + sizeof (thread_state);
  3448. +       m_exec.flavor = THREAD_FLAVOR;
  3449. +       m_exec.count = THREAD_COUNT;
  3450. +       m_exec.state.thread_state_entry_field = entry_symbol
  3451. +     ? entry_symbol->value : text_start + text_header_size;
  3452. +       m_exec.symtab = symtab;
  3453. + #ifdef LC_SYMSEG
  3454. +       m_exec.symseg = symseg;
  3455. + #endif
  3456. +       mywrite((char *) &m_exec, 1, sizeof m_exec, outdesc);
  3457. +       break;
  3458. +     }
  3459. + }
  3460. + 
  3461. + /* Translate a.out style symbols into Mach-O style symbols.  */
  3462. + 
  3463. + void
  3464. + generate_mach_o_symbols (syms, nsyms)
  3465. +      struct nlist *syms;
  3466. +      int nsyms;
  3467. + {
  3468. +   int i;
  3469. + 
  3470. +   for (i = 0; i < nsyms; ++i)
  3471. +     switch (syms[i].n_type)
  3472. +       {
  3473. +       case N_TEXT:
  3474. +       case N_TEXT | N_EXT:
  3475. +     syms[i].n_type = syms[i].n_type & N_EXT | N_SECT;
  3476. +     syms[i].n_sect = 1;    /* text section ordinal */
  3477. +     break;
  3478. +       case N_DATA:
  3479. +       case N_DATA | N_EXT:
  3480. +     syms[i].n_type = syms[i].n_type & N_EXT | N_SECT;
  3481. +     syms[i].n_sect = 2;    /* data section ordinal */
  3482. +     break;
  3483. +       case N_BSS:
  3484. +       case N_BSS | N_EXT:
  3485. +     syms[i].n_type = syms[i].n_type & N_EXT | N_BSS;
  3486. +     syms[i].n_sect = 3;    /* bss section ordinal */
  3487. +     break;
  3488. +       case N_SLINE:
  3489. +     syms[i].n_type = N_SLINE;
  3490. +     syms[i].n_sect = 1;    /* text section ordinal */
  3491. +     break;
  3492. +       case N_DSLINE:
  3493. +     syms[i].n_type = N_SLINE;
  3494. +     syms[i].n_sect = 2;    /* data section ordinal */
  3495. +     break;
  3496. +       case N_BSLINE:
  3497. +     syms[i].n_type = N_SLINE;
  3498. +     syms[i].n_sect = 3;    /* bss section ordinal */
  3499. +     break;
  3500. +       }
  3501. + }
  3502. + 
  3503. + /* Translate a.out style relocation info into Mach-O style relocation
  3504. +    info.  */
  3505. + 
  3506. + void
  3507. + generate_mach_o_relocations (reloc, nreloc)
  3508. +      struct relocation_info *reloc;
  3509. +      int nreloc;
  3510. + {
  3511. +   int i;
  3512. + 
  3513. +   for (i = 0; i < nreloc; ++i)
  3514. +     if (!RELOC_EXTERN_P (&reloc[i]))
  3515. +       switch (RELOC_TYPE (&reloc[i]))
  3516. +     {
  3517. +     case N_ABS:
  3518. +     case N_ABS | N_EXT:
  3519. +       RELOC_TYPE (&reloc[i]) = R_ABS;
  3520. +       break;
  3521. +     case N_TEXT:
  3522. +     case N_TEXT | N_EXT:
  3523. +       RELOC_TYPE (&reloc[i]) = 1; /* output text section ordinal */
  3524. +       break;
  3525. +     case N_DATA:
  3526. +     case N_DATA | N_EXT:
  3527. +       RELOC_TYPE (&reloc[i]) = 2; /* output data section ordinal */
  3528. +       break;
  3529. +     case N_BSS:
  3530. +     case N_BSS | N_EXT:
  3531. +       RELOC_TYPE (&reloc[i]) = 3; /* output bss section ordinal */
  3532. +       break;
  3533. +     }
  3534. + }
  3535. + 
  3536. + #endif
  3537. + 
  3538. + /* The following functions are simple switches according to the
  3539. +    output style.  */
  3540. + 
  3541. + /* Compute text_start and text_header_size as appropriate for the
  3542. +    output format.  */
  3543. + 
  3544. + void
  3545. + initialize_text_start ()
  3546. + {
  3547. + #ifdef A_OUT
  3548. +   if (output_file_type == IS_A_OUT)
  3549. +     {
  3550. +       initialize_a_out_text_start ();
  3551. +       return;
  3552. +     }
  3553. + #endif
  3554. + #ifdef MACH_O
  3555. +   if (output_file_type == IS_MACH_O)
  3556. +     {
  3557. +       initialize_mach_o_text_start ();
  3558. +       return;
  3559. +     }
  3560. + #endif
  3561. +   fatal ("unknown output file type (enum file_type)", (char *) 0);
  3562. + }
  3563. + 
  3564. + /* Initialize data_start as appropriate to the output format, once text_size
  3565. +    is known.  */
  3566. + 
  3567. + void
  3568. + initialize_data_start ()
  3569. + {
  3570. + #ifdef A_OUT
  3571. +   if (output_file_type == IS_A_OUT)
  3572. +     {
  3573. +       initialize_a_out_data_start ();
  3574. +       return;
  3575. +     }
  3576. + #endif
  3577. + #ifdef MACH_O
  3578. +   if (output_file_type == IS_MACH_O)
  3579. +     {
  3580. +       initialize_mach_o_data_start ();
  3581. +       return;
  3582. +     }
  3583. + #endif
  3584. +   fatal ("unknown output file type (enum file_type)", (char *) 0);
  3585. + }
  3586. + 
  3587. + /* Compute offsets of the various sections within the output file.  */
  3588. + 
  3589. + void
  3590. + compute_section_offsets ()
  3591. + {
  3592. + #ifdef A_OUT
  3593. +   if (output_file_type == IS_A_OUT)
  3594. +     {
  3595. +       compute_a_out_section_offsets ();
  3596. +       return;
  3597. +     }
  3598. + #endif
  3599. + #ifdef MACH_O
  3600. +   if (output_file_type == IS_MACH_O)
  3601. +     {
  3602. +       compute_mach_o_section_offsets ();
  3603. +       return;
  3604. +     }
  3605. + #endif
  3606. +   fatal ("unknown output file type (enum file_type)", (char *) 0);
  3607. + }
  3608. + 
  3609. + /* Compute more section offsets, once the size of the string table
  3610. +    is finalized.  */
  3611. + void
  3612. + compute_more_section_offsets ()
  3613. + {
  3614. + #ifdef A_OUT
  3615. +   if (output_file_type == IS_A_OUT)
  3616. +     {
  3617. +       compute_more_a_out_section_offsets ();
  3618. +       return;
  3619. +     }
  3620. + #endif
  3621. + #ifdef MACH_O
  3622. +   if (output_file_type == IS_MACH_O)
  3623. +     {
  3624. +       compute_more_mach_o_section_offsets ();
  3625. +       return;
  3626. +     }
  3627. + #endif
  3628. +   fatal ("unknown output file type (enum file_type)", (char *) 0);
  3629. + }
  3630. + 
  3631. + /* Write the output file header, once everything is known.  */
  3632. + void
  3633. + write_header ()
  3634. + {
  3635. + #ifdef A_OUT
  3636. +   if (output_file_type == IS_A_OUT)
  3637. +     {
  3638. +       write_a_out_header ();
  3639. +       return;
  3640. +     }
  3641. + #endif
  3642. + #ifdef MACH_O
  3643. +   if (output_file_type == IS_MACH_O)
  3644. +     {
  3645. +       write_mach_o_header ();
  3646. +       return;
  3647. +     }
  3648. + #endif
  3649. +   fatal ("unknown output file type (enum file_type)", (char *) 0);
  3650. + }
  3651. + 
  3652. + /* Write the output file */
  3653. + 
  3654. + void
  3655. + write_output ()
  3656. + {
  3657. +   struct stat statbuf;
  3658. +   int filemode, mask;
  3659. + 
  3660. +   /* Remove the old file in case it is owned by someone else.
  3661. +      This prevents spurious "not owner" error messages.
  3662. +      Don't check for errors from unlink; we don't really care
  3663. +      whether it worked.
  3664. + 
  3665. +      Note that this means that if the output file is hard linked,
  3666. +      the other names will still have the old contents.  This is
  3667. +      the way Unix ld works; I'm going to consider it a feature.  */
  3668. +   (void) unlink (output_filename);
  3669. +   
  3670. +   outdesc = open (output_filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
  3671. +   if (outdesc < 0) perror_name (output_filename);
  3672. + 
  3673. +   if (fstat (outdesc, &statbuf) < 0)
  3674. +     perror_name (output_filename);
  3675. + 
  3676. +   filemode = statbuf.st_mode;
  3677. + 
  3678. +   chmod (output_filename, filemode & ~0111);
  3679. + 
  3680. +   /* Calculate the offsets of the various pieces of the output file.  */
  3681. +   compute_section_offsets ();
  3682. + 
  3683. +   /* Output the text and data segments, relocating as we go.  */
  3684. +   write_text ();
  3685. +   write_data ();
  3686. + 
  3687. +   /* Output the merged relocation info, if requested with `-r'.  */
  3688. +   if (output_style == OUTPUT_RELOCATABLE)
  3689. +     write_rel ();
  3690. + 
  3691. +   /* Output the symbol table (both globals and locals).  */
  3692. +   write_syms ();
  3693. + 
  3694. +   /* At this point the total size of the symbol table and string table
  3695. +      are finalized.  */
  3696. +   compute_more_section_offsets ();
  3697. + 
  3698. +   /* Copy any GDB symbol segments from input files.  */
  3699. +   write_symsegs ();
  3700. + 
  3701. +   /* Now that everything is known about the output file, write its header.  */
  3702. +   write_header ();
  3703. + 
  3704. +   close (outdesc);
  3705. + 
  3706. +   mask = umask (0);
  3707. +   umask (mask);
  3708. + 
  3709. +   if (chmod (output_filename, filemode | (0111 & ~mask)) == -1)
  3710. +     perror_name (output_filename);
  3711. + }
  3712.   
  3713. + void modify_location (), perform_relocation (), copy_text (), copy_data ();
  3714. + 
  3715.   /* Relocate the text segment of each input file
  3716.      and write to the output file.  */
  3717.   
  3718. ***************
  3719. *** 3442,3448 ****
  3720.     if (trace_files)
  3721.       fprintf (stderr, "Copying and relocating text:\n\n");
  3722.   
  3723. !   each_full_file (copy_text);
  3724.     file_close ();
  3725.   
  3726.     if (trace_files)
  3727. --- 4574,4582 ----
  3728.     if (trace_files)
  3729.       fprintf (stderr, "Copying and relocating text:\n\n");
  3730.   
  3731. !   lseek (outdesc, output_text_offset + text_header_size, 0);
  3732. ! 
  3733. !   each_full_file (copy_text, 0);
  3734.     file_close ();
  3735.   
  3736.     if (trace_files)
  3737. ***************
  3738. *** 3451,3469 ****
  3739.     padfile (text_pad, outdesc);
  3740.   }
  3741.   
  3742. - int
  3743. - text_offset (entry)
  3744. -      struct file_entry *entry;
  3745. - {
  3746. -   return entry->starting_offset + N_TXTOFF (entry->header);
  3747. - }
  3748. - 
  3749.   /* Read in all of the relocation information */
  3750.   
  3751.   void
  3752.   read_relocation ()
  3753.   {
  3754. !   each_full_file (read_file_relocation);
  3755.   }
  3756.   
  3757.   /* Read in the relocation sections of ENTRY if necessary */
  3758. --- 4585,4596 ----
  3759.     padfile (text_pad, outdesc);
  3760.   }
  3761.   
  3762.   /* Read in all of the relocation information */
  3763.   
  3764.   void
  3765.   read_relocation ()
  3766.   {
  3767. !   each_full_file (read_file_relocation, 0);
  3768.   }
  3769.   
  3770.   /* Read in the relocation sections of ENTRY if necessary */
  3771. ***************
  3772. *** 3479,3490 ****
  3773.     desc = -1;
  3774.     if (!entry->textrel)
  3775.       {
  3776. !       reloc = (struct relocation_info *) xmalloc (entry->header.a_trsize);
  3777.         desc = file_open (entry);
  3778. !       lseek (desc,
  3779. !          text_offset (entry) + entry->header.a_text + entry->header.a_data,
  3780. !          L_SET);
  3781. !       if (entry->header.a_trsize != (read_return = read (desc, reloc, entry->header.a_trsize)))
  3782.       {
  3783.         fprintf (stderr, "Return from read: %d\n", read_return);
  3784.         fatal_with_file ("premature eof in text relocation of ", entry);
  3785. --- 4606,4615 ----
  3786.     desc = -1;
  3787.     if (!entry->textrel)
  3788.       {
  3789. !       reloc = (struct relocation_info *) xmalloc (entry->text_reloc_size);
  3790.         desc = file_open (entry);
  3791. !       lseek (desc, entry->starting_offset + entry->text_reloc_offset, L_SET);
  3792. !       if (entry->text_reloc_size != (read_return = read (desc, reloc, entry->text_reloc_size)))
  3793.       {
  3794.         fprintf (stderr, "Return from read: %d\n", read_return);
  3795.         fatal_with_file ("premature eof in text relocation of ", entry);
  3796. ***************
  3797. *** 3494,3509 ****
  3798.   
  3799.     if (!entry->datarel)
  3800.       {
  3801. !       reloc = (struct relocation_info *) xmalloc (entry->header.a_drsize);
  3802.         if (desc == -1) desc = file_open (entry);
  3803. !       lseek (desc,
  3804. !          text_offset (entry) + entry->header.a_text
  3805. !          + entry->header.a_data + entry->header.a_trsize,
  3806. !          L_SET);
  3807. !       if (entry->header.a_drsize != read (desc, reloc, entry->header.a_drsize))
  3808.       fatal_with_file ("premature eof in data relocation of ", entry);
  3809.         entry->datarel = reloc;
  3810.       }
  3811.   }
  3812.   
  3813.   /* Read the text segment contents of ENTRY, relocate them,
  3814. --- 4619,4641 ----
  3815.   
  3816.     if (!entry->datarel)
  3817.       {
  3818. !       reloc = (struct relocation_info *) xmalloc (entry->data_reloc_size);
  3819.         if (desc == -1) desc = file_open (entry);
  3820. !       lseek (desc, entry->starting_offset + entry->data_reloc_offset, L_SET);
  3821. !       if (entry->data_reloc_size != read (desc, reloc, entry->data_reloc_size))
  3822.       fatal_with_file ("premature eof in data relocation of ", entry);
  3823.         entry->datarel = reloc;
  3824.       }
  3825. + 
  3826. + #ifdef MACH_O
  3827. +   if (entry->file_type == IS_MACH_O)
  3828. +     {
  3829. +       translate_mach_o_relocation (entry, entry->textrel,
  3830. +                    entry->text_reloc_size / sizeof (struct relocation_info));
  3831. +       translate_mach_o_relocation (entry, entry->datarel,
  3832. +                    entry->data_reloc_size / sizeof (struct relocation_info));
  3833. +     }
  3834. + #endif
  3835.   }
  3836.   
  3837.   /* Read the text segment contents of ENTRY, relocate them,
  3838. ***************
  3839. *** 3525,3536 ****
  3840.   
  3841.     /* Allocate space for the file's text section */
  3842.   
  3843. !   bytes = (char *) alloca (entry->header.a_text);
  3844.   
  3845.     /* Deal with relocation information however is appropriate */
  3846.   
  3847.     if (entry->textrel)  reloc = entry->textrel;
  3848. !   else if (relocatable_output)
  3849.       {
  3850.         read_file_relocation (entry);
  3851.         reloc = entry->textrel;
  3852. --- 4657,4668 ----
  3853.   
  3854.     /* Allocate space for the file's text section */
  3855.   
  3856. !   bytes = (char *) alloca (entry->text_size);
  3857.   
  3858.     /* Deal with relocation information however is appropriate */
  3859.   
  3860.     if (entry->textrel)  reloc = entry->textrel;
  3861. !   else if (output_style == OUTPUT_RELOCATABLE)
  3862.       {
  3863.         read_file_relocation (entry);
  3864.         reloc = entry->textrel;
  3865. ***************
  3866. *** 3537,3563 ****
  3867.       }
  3868.     else
  3869.       {
  3870. !       reloc = (struct relocation_info *) alloca (entry->header.a_trsize);
  3871. !       lseek (desc, text_offset (entry) + entry->header.a_text + entry->header.a_data, 0);
  3872. !       if (entry->header.a_trsize != read (desc, reloc, entry->header.a_trsize))
  3873.       fatal_with_file ("premature eof in text relocation of ", entry);
  3874.       }
  3875.   
  3876.     /* Read the text section into core.  */
  3877.   
  3878. !   lseek (desc, text_offset (entry), 0);
  3879. !   if (entry->header.a_text != read (desc, bytes, entry->header.a_text))
  3880.       fatal_with_file ("premature eof in text section of ", entry);
  3881.   
  3882. - 
  3883.     /* Relocate the text according to the text relocation.  */
  3884.   
  3885. !   perform_relocation (bytes, entry->text_start_address, entry->header.a_text,
  3886. !               reloc, entry->header.a_trsize, entry);
  3887.   
  3888.     /* Write the relocated text to the output file.  */
  3889.   
  3890. !   mywrite (bytes, 1, entry->header.a_text, outdesc);
  3891.   }
  3892.   
  3893.   /* Relocate the data segment of each input file
  3894. --- 4669,4699 ----
  3895.       }
  3896.     else
  3897.       {
  3898. !       reloc = (struct relocation_info *) alloca (entry->text_reloc_size);
  3899. !       lseek (desc, entry->starting_offset + entry->text_reloc_offset, L_SET);
  3900. !       if (entry->text_reloc_size != read (desc, reloc, entry->text_reloc_size))
  3901.       fatal_with_file ("premature eof in text relocation of ", entry);
  3902. + #ifdef MACH_O
  3903. +       if (entry->file_type == IS_MACH_O)
  3904. +     translate_mach_o_relocation (entry, reloc,
  3905. +                      entry->text_reloc_size / sizeof (struct relocation_info));
  3906. + #endif
  3907.       }
  3908.   
  3909.     /* Read the text section into core.  */
  3910.   
  3911. !   lseek (desc, entry->starting_offset + entry->text_offset, L_SET);
  3912. !   if (entry->text_size != read (desc, bytes, entry->text_size))
  3913.       fatal_with_file ("premature eof in text section of ", entry);
  3914.   
  3915.     /* Relocate the text according to the text relocation.  */
  3916.   
  3917. !   perform_relocation (bytes, entry->text_start_address - entry->orig_text_address,
  3918. !               entry->text_size, reloc, entry->text_reloc_size, entry);
  3919.   
  3920.     /* Write the relocated text to the output file.  */
  3921.   
  3922. !   mywrite (bytes, 1, entry->text_size, outdesc);
  3923.   }
  3924.   
  3925.   /* Relocate the data segment of each input file
  3926. ***************
  3927. *** 3569,3575 ****
  3928.     if (trace_files)
  3929.       fprintf (stderr, "Copying and relocating data:\n\n");
  3930.   
  3931. !   each_full_file (copy_data);
  3932.     file_close ();
  3933.   
  3934.     /* Write out the set element vectors.  See digest symbols for
  3935. --- 4705,4713 ----
  3936.     if (trace_files)
  3937.       fprintf (stderr, "Copying and relocating data:\n\n");
  3938.   
  3939. !   lseek (outdesc, output_data_offset, 0);
  3940. ! 
  3941. !   each_full_file (copy_data, 0);
  3942.     file_close ();
  3943.   
  3944.     /* Write out the set element vectors.  See digest symbols for
  3945. ***************
  3946. *** 3603,3612 ****
  3947.   
  3948.     desc = file_open (entry);
  3949.   
  3950. !   bytes = (char *) alloca (entry->header.a_data);
  3951.   
  3952.     if (entry->datarel) reloc = entry->datarel;
  3953. !   else if (relocatable_output)    /* Will need this again */
  3954.       {
  3955.         read_file_relocation (entry);
  3956.         reloc = entry->datarel;
  3957. --- 4741,4750 ----
  3958.   
  3959.     desc = file_open (entry);
  3960.   
  3961. !   bytes = (char *) alloca (entry->data_size);
  3962.   
  3963.     if (entry->datarel) reloc = entry->datarel;
  3964. !   else if (output_style == OUTPUT_RELOCATABLE)    /* Will need this again */
  3965.       {
  3966.         read_file_relocation (entry);
  3967.         reloc = entry->datarel;
  3968. ***************
  3969. *** 3613,3634 ****
  3970.       }
  3971.     else
  3972.       {
  3973. !       reloc = (struct relocation_info *) alloca (entry->header.a_drsize);
  3974. !       lseek (desc, text_offset (entry) + entry->header.a_text
  3975. !          + entry->header.a_data + entry->header.a_trsize,
  3976. !          0);
  3977. !       if (entry->header.a_drsize != read (desc, reloc, entry->header.a_drsize))
  3978.       fatal_with_file ("premature eof in data relocation of ", entry);
  3979.       }
  3980.   
  3981. !   lseek (desc, text_offset (entry) + entry->header.a_text, 0);
  3982. !   if (entry->header.a_data != read (desc, bytes, entry->header.a_data))
  3983.       fatal_with_file ("premature eof in data section of ", entry);
  3984.   
  3985. !   perform_relocation (bytes, entry->data_start_address - entry->header.a_text,
  3986. !               entry->header.a_data, reloc, entry->header.a_drsize, entry);
  3987.   
  3988. !   mywrite (bytes, 1, entry->header.a_data, outdesc);
  3989.   }
  3990.   
  3991.   /* Relocate ENTRY's text or data section contents.
  3992. --- 4751,4775 ----
  3993.       }
  3994.     else
  3995.       {
  3996. !       reloc = (struct relocation_info *) alloca (entry->data_reloc_size);
  3997. !       lseek (desc, entry->starting_offset + entry->data_reloc_offset, L_SET);
  3998. !       if (entry->data_reloc_size != read (desc, reloc, entry->data_reloc_size))
  3999.       fatal_with_file ("premature eof in data relocation of ", entry);
  4000. + #ifdef MACH_O
  4001. +       if (entry->file_type == IS_MACH_O)
  4002. +     translate_mach_o_relocation (entry, reloc,
  4003. +                      entry->data_reloc_size / sizeof (struct relocation_info));
  4004. + #endif
  4005.       }
  4006.   
  4007. !   lseek (desc, entry->starting_offset + entry->data_offset, L_SET);
  4008. !   if (entry->data_size != read (desc, bytes, entry->data_size))
  4009.       fatal_with_file ("premature eof in data section of ", entry);
  4010.   
  4011. !   perform_relocation (bytes, entry->data_start_address - entry->orig_data_address,
  4012. !               entry->data_size, reloc, entry->data_reloc_size, entry);
  4013.   
  4014. !   mywrite (bytes, 1, entry->data_size, outdesc);
  4015.   }
  4016.   
  4017.   /* Relocate ENTRY's text or data section contents.
  4018. ***************
  4019. *** 3638,3644 ****
  4020.        in the output file and its address in the input file.
  4021.      RELOC_INFO is the address of the relocation info, in core.
  4022.      RELOC_SIZE is its length in bytes.  */
  4023. ! /* This version is about to be severley hacked by Randy.  Hope it
  4024.      works afterwards. */
  4025.   void
  4026.   perform_relocation (data, pc_relocation, data_size, reloc_info, reloc_size, entry)
  4027. --- 4779,4785 ----
  4028.        in the output file and its address in the input file.
  4029.      RELOC_INFO is the address of the relocation info, in core.
  4030.      RELOC_SIZE is its length in bytes.  */
  4031. ! /* This version is about to be severly hacked by Randy.  Hope it
  4032.      works afterwards. */
  4033.   void
  4034.   perform_relocation (data, pc_relocation, data_size, reloc_info, reloc_size, entry)
  4035. ***************
  4036. *** 3652,3661 ****
  4037.     register struct relocation_info *p = reloc_info;
  4038.     struct relocation_info *end
  4039.       = reloc_info + reloc_size / sizeof (struct relocation_info);
  4040. !   int text_relocation = entry->text_start_address;
  4041. !   int data_relocation = entry->data_start_address - entry->header.a_text;
  4042. !   int bss_relocation
  4043. !     = entry->bss_start_address - entry->header.a_text - entry->header.a_data;
  4044.   
  4045.     for (; p < end; p++)
  4046.       {
  4047. --- 4793,4801 ----
  4048.     register struct relocation_info *p = reloc_info;
  4049.     struct relocation_info *end
  4050.       = reloc_info + reloc_size / sizeof (struct relocation_info);
  4051. !   int text_relocation = entry->text_start_address - entry->orig_text_address;
  4052. !   int data_relocation = entry->data_start_address - entry->orig_data_address;
  4053. !   int bss_relocation = entry->bss_start_address - entry->orig_bss_address;
  4054.   
  4055.     for (; p < end; p++)
  4056.       {
  4057. ***************
  4058. *** 3680,3686 ****
  4059.           sp = (symbol *) sp->value;
  4060.   #endif
  4061.   
  4062. !       if (symindex >= entry->header.a_syms)
  4063.           fatal_with_file ("relocation symbolnum out of range in ", entry);
  4064.   
  4065.         /* If the symbol is undefined, leave it at zero.  */
  4066. --- 4820,4826 ----
  4067.           sp = (symbol *) sp->value;
  4068.   #endif
  4069.   
  4070. !       if (symindex >= entry->syms_size)
  4071.           fatal_with_file ("relocation symbolnum out of range in ", entry);
  4072.   
  4073.         /* If the symbol is undefined, leave it at zero.  */
  4074. ***************
  4075. *** 3698,3713 ****
  4076.   
  4077.       case N_DATA:
  4078.       case N_DATA | N_EXT:
  4079. -       /* A word that points to beginning of the the data section
  4080. -          initially contains not 0 but rather the "address" of that section
  4081. -          in the input file, which is the length of the file's text.  */
  4082.         relocation = data_relocation;
  4083.         break;
  4084.   
  4085.       case N_BSS:
  4086.       case N_BSS | N_EXT:
  4087. -       /* Similarly, an input word pointing to the beginning of the bss
  4088. -          initially contains the length of text plus data of the file.  */
  4089.         relocation = bss_relocation;
  4090.         break;
  4091.   
  4092. --- 4838,4848 ----
  4093. ***************
  4094. *** 3725,3731 ****
  4095.   
  4096.   #ifdef RELOC_ADD_EXTRA
  4097.         relocation += RELOC_ADD_EXTRA(p);
  4098. !       if (relocatable_output)
  4099.       {
  4100.         /* If this RELOC_ADD_EXTRA is 0, it means that the
  4101.            symbol was external and the relocation does not
  4102. --- 4860,4866 ----
  4103.   
  4104.   #ifdef RELOC_ADD_EXTRA
  4105.         relocation += RELOC_ADD_EXTRA(p);
  4106. !       if (output_style == OUTPUT_RELOCATABLE)
  4107.       {
  4108.         /* If this RELOC_ADD_EXTRA is 0, it means that the
  4109.            symbol was external and the relocation does not
  4110. ***************
  4111. *** 3783,3794 ****
  4112. --- 4918,4946 ----
  4113.         break;
  4114.   
  4115.       case 2:
  4116. + #ifdef CROSS_LINKER
  4117. +       /* This is necessary if the host has stricter alignment
  4118. +          than the target.  Too slow to use all the time.
  4119. +          Also doesn't deal with differing byte-order.  */
  4120. +       {
  4121. +         /* Thing to relocate.  */
  4122. +         long thing;
  4123. +         bcopy (data + addr, &thing, sizeof (thing));
  4124.           if (RELOC_MEMORY_SUB_P (p))
  4125. +           relocation -= mask & thing;
  4126. +         else if (RELOC_MEMORY_ADD_P (p))
  4127. +           relocation += mask & thing;
  4128. +         thing = (thing & ~mask) | relocation;
  4129. +         bcopy (&thing, data + addr, sizeof (thing));
  4130. +       }
  4131. + #else /* not CROSS_LINKER */
  4132. +       if (RELOC_MEMORY_SUB_P(p))
  4133.           relocation -= mask & *(long *) (data + addr);
  4134.         else if (RELOC_MEMORY_ADD_P(p))
  4135.           relocation += mask & *(long *) (data + addr);
  4136.         *(long *) (data + addr) &= ~mask;
  4137.         *(long *) (data + addr) |= relocation;
  4138. + #endif /* not CROSS_LINKER */
  4139.         break;
  4140.   
  4141.       default:
  4142. ***************
  4143. *** 3797,3803 ****
  4144.       }
  4145.   }
  4146.   
  4147. ! /* For relocatable_output only: write out the relocation,
  4148.      relocating the addresses-to-be-relocated.  */
  4149.   
  4150.   void coptxtrel (), copdatrel ();
  4151. --- 4949,4955 ----
  4152.       }
  4153.   }
  4154.   
  4155. ! /* For OUTPUT_RELOCATABLE only: write out the relocation,
  4156.      relocating the addresses-to-be-relocated.  */
  4157.   
  4158.   void coptxtrel (), copdatrel ();
  4159. ***************
  4160. *** 3823,3848 ****
  4161.       if (sp->referenced || sp->defined)
  4162.         {
  4163.           sp->def_count = count++;
  4164.           /* Leave room for the reference required by N_INDR, if
  4165.              necessary.  */
  4166.           if ((sp->defined & ~N_EXT) == N_INDR)
  4167.             count++;
  4168.         }
  4169.       }
  4170. !   /* Correct, because if (reloatable_output), we will also be writing
  4171.        whatever indirect blocks we have.  */
  4172.     if (count != defined_global_sym_count
  4173.         + undefined_global_sym_count + global_indirect_count)
  4174.       fatal ("internal error");
  4175.   
  4176.     /* Write out the relocations of all files, remembered from copy_text.  */
  4177.   
  4178. !   each_full_file (coptxtrel);
  4179.   
  4180.     if (trace_files)
  4181.       fprintf (stderr, "\nWriting data relocation:\n\n");
  4182.   
  4183. !   each_full_file (copdatrel);
  4184.   
  4185.     if (trace_files)
  4186.       fprintf (stderr, "\n");
  4187. --- 4975,5009 ----
  4188.       if (sp->referenced || sp->defined)
  4189.         {
  4190.           sp->def_count = count++;
  4191. + #ifndef NeXT
  4192.           /* Leave room for the reference required by N_INDR, if
  4193.              necessary.  */
  4194.           if ((sp->defined & ~N_EXT) == N_INDR)
  4195.             count++;
  4196. + #endif
  4197.         }
  4198.       }
  4199. !   /* Correct, because if (OUTPUT_RELOCATABLE), we will also be writing
  4200.        whatever indirect blocks we have.  */
  4201. + #ifndef NeXT
  4202.     if (count != defined_global_sym_count
  4203.         + undefined_global_sym_count + global_indirect_count)
  4204. + #else
  4205. +   if (count != defined_global_sym_count
  4206. +       + undefined_global_sym_count)
  4207. + #endif
  4208.       fatal ("internal error");
  4209.   
  4210.     /* Write out the relocations of all files, remembered from copy_text.  */
  4211.   
  4212. !   lseek (outdesc, output_trel_offset, 0);
  4213. !   each_full_file (coptxtrel, 0);
  4214.   
  4215.     if (trace_files)
  4216.       fprintf (stderr, "\nWriting data relocation:\n\n");
  4217.   
  4218. !   lseek (outdesc, output_drel_offset, 0);
  4219. !   each_full_file (copdatrel, 0);
  4220.   
  4221.     if (trace_files)
  4222.       fprintf (stderr, "\n");
  4223. ***************
  4224. *** 3853,3862 ****
  4225.        struct file_entry *entry;
  4226.   {
  4227.     register struct relocation_info *p, *end;
  4228. !   register int reloc = entry->text_start_address;
  4229.   
  4230.     p = entry->textrel;
  4231. !   end = (struct relocation_info *) (entry->header.a_trsize + (char *) p);
  4232.     while (p < end)
  4233.       {
  4234.         RELOC_ADDRESS(p) += reloc;
  4235. --- 5014,5023 ----
  4236.        struct file_entry *entry;
  4237.   {
  4238.     register struct relocation_info *p, *end;
  4239. !   register int reloc = entry->text_start_address - text_start;
  4240.   
  4241.     p = entry->textrel;
  4242. !   end = (struct relocation_info *) (entry->text_reloc_size + (char *) p);
  4243.     while (p < end)
  4244.       {
  4245.         RELOC_ADDRESS(p) += reloc;
  4246. ***************
  4247. *** 3868,3874 ****
  4248.                     (((char *)entry->symbols) + symindex))
  4249.                    ->n_un.n_name));
  4250.   
  4251. !       if (symindex >= entry->header.a_syms)
  4252.           fatal_with_file ("relocation symbolnum out of range in ", entry);
  4253.   
  4254.   #ifdef N_INDR
  4255. --- 5029,5035 ----
  4256.                     (((char *)entry->symbols) + symindex))
  4257.                    ->n_un.n_name));
  4258.   
  4259. !       if (symindex >= entry->syms_size)
  4260.           fatal_with_file ("relocation symbolnum out of range in ", entry);
  4261.   
  4262.   #ifdef N_INDR
  4263. ***************
  4264. *** 3883,3889 ****
  4265.         if (symptr->defined)
  4266.           {
  4267.             RELOC_EXTERN_P(p) = 0;
  4268. !           RELOC_SYMBOL(p) = (symptr->defined & N_TYPE);
  4269.   #ifdef RELOC_ADD_EXTRA
  4270.             /* If we aren't going to be adding in the value in
  4271.                memory on the next pass of the loader, then we need
  4272. --- 5044,5050 ----
  4273.         if (symptr->defined)
  4274.           {
  4275.             RELOC_EXTERN_P(p) = 0;
  4276. !           RELOC_SYMBOL(p) = (symptr->defined & ~N_EXT);
  4277.   #ifdef RELOC_ADD_EXTRA
  4278.             /* If we aren't going to be adding in the value in
  4279.                memory on the next pass of the loader, then we need
  4280. ***************
  4281. *** 3896,3909 ****
  4282.         else
  4283.           /* Debugger symbols come first, so have to start this
  4284.              after them.  */
  4285.             RELOC_SYMBOL(p) = (symptr->def_count + nsyms
  4286.                    - defined_global_sym_count
  4287.                    - undefined_global_sym_count
  4288.                    - global_indirect_count);
  4289.       }
  4290.         p++;
  4291.       }
  4292. !   mywrite (entry->textrel, 1, entry->header.a_trsize, outdesc);
  4293.   }
  4294.   
  4295.   void
  4296. --- 5057,5083 ----
  4297.         else
  4298.           /* Debugger symbols come first, so have to start this
  4299.              after them.  */
  4300. + #ifndef NeXT
  4301.             RELOC_SYMBOL(p) = (symptr->def_count + nsyms
  4302.                    - defined_global_sym_count
  4303.                    - undefined_global_sym_count
  4304.                    - global_indirect_count);
  4305. + #else
  4306. +           RELOC_SYMBOL(p) = (symptr->def_count + nsyms
  4307. +                  - defined_global_sym_count
  4308. +                  - undefined_global_sym_count);
  4309. + #endif
  4310.       }
  4311.         p++;
  4312.       }
  4313. ! 
  4314. ! #ifdef MACH_O
  4315. !   if (output_file_type == IS_MACH_O)
  4316. !     generate_mach_o_relocations(entry->textrel,
  4317. !                 entry->text_reloc_size / sizeof (struct relocation_info));
  4318. ! #endif
  4319. ! 
  4320. !   mywrite (entry->textrel, 1, entry->text_reloc_size, outdesc);
  4321.   }
  4322.   
  4323.   void
  4324. ***************
  4325. *** 3913,3923 ****
  4326.     register struct relocation_info *p, *end;
  4327.     /* Relocate the address of the relocation.
  4328.        Old address is relative to start of the input file's data section.
  4329. !      New address is relative to start of the output file's data section.  */
  4330. !   register int reloc = entry->data_start_address - text_size;
  4331.   
  4332.     p = entry->datarel;
  4333. !   end = (struct relocation_info *) (entry->header.a_drsize + (char *) p);
  4334.     while (p < end)
  4335.       {
  4336.         RELOC_ADDRESS(p) += reloc;
  4337. --- 5087,5100 ----
  4338.     register struct relocation_info *p, *end;
  4339.     /* Relocate the address of the relocation.
  4340.        Old address is relative to start of the input file's data section.
  4341. !      New address is relative to start of the output file's data section.
  4342. ! 
  4343. !      So the amount we need to relocate it by is the offset of this
  4344. !      input file's data section within the output file's data section.  */
  4345. !   register int reloc = entry->data_start_address - data_start;
  4346.   
  4347.     p = entry->datarel;
  4348. !   end = (struct relocation_info *) (entry->data_reloc_size + (char *) p);
  4349.     while (p < end)
  4350.       {
  4351.         RELOC_ADDRESS(p) += reloc;
  4352. ***************
  4353. *** 3930,3936 ****
  4354.                    ->n_un.n_name));
  4355.         int symtype;
  4356.   
  4357. !       if (symindex >= entry->header.a_syms)
  4358.           fatal_with_file ("relocation symbolnum out of range in ", entry);
  4359.   
  4360.   #ifdef N_INDR
  4361. --- 5107,5113 ----
  4362.                    ->n_un.n_name));
  4363.         int symtype;
  4364.   
  4365. !       if (symindex >= entry->syms_size)
  4366.           fatal_with_file ("relocation symbolnum out of range in ", entry);
  4367.   
  4368.   #ifdef N_INDR
  4369. ***************
  4370. *** 3939,3945 ****
  4371.           symptr = (symbol *) symptr->value;
  4372.   #endif
  4373.   
  4374. !        symtype = symptr->defined & N_TYPE;
  4375.   
  4376.         if (force_common_definition
  4377.             || symtype == N_DATA || symtype == N_TEXT || symtype == N_ABS)
  4378. --- 5116,5122 ----
  4379.           symptr = (symbol *) symptr->value;
  4380.   #endif
  4381.   
  4382. !       symtype = symptr->defined & ~N_EXT;
  4383.   
  4384.         if (force_common_definition
  4385.             || symtype == N_DATA || symtype == N_TEXT || symtype == N_ABS)
  4386. ***************
  4387. *** 3950,3955 ****
  4388. --- 5127,5133 ----
  4389.         else
  4390.           /* Debugger symbols come first, so have to start this
  4391.              after them.  */
  4392. + #ifndef NeXT
  4393.           RELOC_SYMBOL(p)
  4394.             = (((symbol *)
  4395.             (((struct nlist *)
  4396. ***************
  4397. *** 3959,3985 ****
  4398.            + nsyms - defined_global_sym_count
  4399.            - undefined_global_sym_count
  4400.            - global_indirect_count);
  4401.       }
  4402.         p++;
  4403.       }
  4404. !   mywrite (entry->datarel, 1, entry->header.a_drsize, outdesc);
  4405.   }
  4406.   
  4407.   void write_file_syms ();
  4408.   void write_string_table ();
  4409.   
  4410. - /* Offsets and current lengths of symbol and string tables in output file. */
  4411. - 
  4412. - int symbol_table_offset;
  4413. - int symbol_table_len;
  4414. - 
  4415. - /* Address in output file where string table starts.  */
  4416. - int string_table_offset;
  4417. - 
  4418. - /* Offset within string table
  4419. -    where the strings in `strtab_vector' should be written.  */
  4420. - int string_table_len;
  4421. - 
  4422.   /* Total size of string table strings allocated so far,
  4423.      including strings in `strtab_vector'.  */
  4424.   int strtab_size;
  4425. --- 5137,5167 ----
  4426.            + nsyms - defined_global_sym_count
  4427.            - undefined_global_sym_count
  4428.            - global_indirect_count);
  4429. + #else
  4430. +         RELOC_SYMBOL(p)
  4431. +           = (((symbol *)
  4432. +           (((struct nlist *)
  4433. +             (((char *)entry->symbols) + symindex))
  4434. +            ->n_un.n_name))
  4435. +          ->def_count
  4436. +          + nsyms - defined_global_sym_count
  4437. +          - undefined_global_sym_count);
  4438. + #endif
  4439.       }
  4440.         p++;
  4441.       }
  4442. ! #ifdef MACH_O
  4443. !   if (output_file_type == IS_MACH_O)
  4444. !     generate_mach_o_relocations(entry->datarel,
  4445. !                 entry->data_reloc_size / sizeof (struct relocation_info));
  4446. ! #endif
  4447. ! 
  4448. !   mywrite (entry->datarel, 1, entry->data_reloc_size, outdesc);
  4449.   }
  4450.   
  4451.   void write_file_syms ();
  4452.   void write_string_table ();
  4453.   
  4454.   /* Total size of string table strings allocated so far,
  4455.      including strings in `strtab_vector'.  */
  4456.   int strtab_size;
  4457. ***************
  4458. *** 4022,4028 ****
  4459.   {
  4460.     register int i;
  4461.   
  4462. !   lseek (outdesc, string_table_offset + string_table_len, 0);
  4463.   
  4464.     if (!outstream)
  4465.       outstream = fdopen (outdesc, "w");
  4466. --- 5204,5210 ----
  4467.   {
  4468.     register int i;
  4469.   
  4470. !   lseek (outdesc, output_strs_offset + output_strs_size, 0);
  4471.   
  4472.     if (!outstream)
  4473.       outstream = fdopen (outdesc, "w");
  4474. ***************
  4475. *** 4030,4036 ****
  4476.     for (i = 0; i < strtab_index; i++)
  4477.       {
  4478.         fwrite (strtab_vector[i], 1, strtab_lens[i], outstream);
  4479. !       string_table_len += strtab_lens[i];
  4480.       }
  4481.   
  4482.     fflush (outstream);
  4483. --- 5212,5218 ----
  4484.     for (i = 0; i < strtab_index; i++)
  4485.       {
  4486.         fwrite (strtab_vector[i], 1, strtab_lens[i], outstream);
  4487. !       output_strs_size += strtab_lens[i];
  4488.       }
  4489.   
  4490.     fflush (outstream);
  4491. ***************
  4492. *** 4054,4063 ****
  4493. --- 5236,5251 ----
  4494.        extra struct for each indirect symbol to hold the extra reference
  4495.        following. */
  4496.     struct nlist *buf
  4497. + #ifndef NeXT
  4498.       = (struct nlist *) alloca ((defined_global_sym_count
  4499.                   + undefined_global_sym_count
  4500.                   + global_indirect_count)
  4501.                      * sizeof (struct nlist));
  4502. + #else
  4503. +     = (struct nlist *) alloca ((defined_global_sym_count
  4504. +                 + undefined_global_sym_count)
  4505. +                    * sizeof (struct nlist));
  4506. + #endif
  4507.     /* Pointer for storing into BUF.  */
  4508.     register struct nlist *bufp = buf;
  4509.   
  4510. ***************
  4511. *** 4064,4073 ****
  4512.     /* Size of string table includes the bytes that store the size.  */
  4513.     strtab_size = sizeof strtab_size;
  4514.   
  4515. !   symbol_table_offset = N_SYMOFF (outheader);
  4516. !   symbol_table_len = 0;
  4517. !   string_table_offset = N_STROFF (outheader);
  4518. !   string_table_len = strtab_size;
  4519.   
  4520.     if (strip_symbols == STRIP_ALL)
  4521.       return;
  4522. --- 5252,5259 ----
  4523.     /* Size of string table includes the bytes that store the size.  */
  4524.     strtab_size = sizeof strtab_size;
  4525.   
  4526. !   output_syms_size = 0;
  4527. !   output_strs_size = strtab_size;
  4528.   
  4529.     if (strip_symbols == STRIP_ALL)
  4530.       return;
  4531. ***************
  4532. *** 4096,4102 ****
  4533. --- 5282,5292 ----
  4534.         {
  4535.       struct nlist nl;
  4536.   
  4537. + #ifdef N_SECT
  4538. +     nl.n_sect = 0;
  4539. + #else
  4540.       nl.n_other = 0;
  4541. + #endif
  4542.       nl.n_desc = 0;
  4543.   
  4544.       /* Compute a `struct nlist' for the symbol.  */
  4545. ***************
  4546. *** 4111,4118 ****
  4547.           /* If the target of an indirect symbol has been
  4548.              defined and we are outputting an executable,
  4549.              resolve the indirection; it's no longer needed */
  4550. !         if (!relocatable_output
  4551. !             && ((sp->defined & N_TYPE) == N_INDR)
  4552.               && (((symbol *) sp->value)->defined > 1))
  4553.             {
  4554.               symbol *newsp = (symbol *) sp->value;
  4555. --- 5301,5308 ----
  4556.           /* If the target of an indirect symbol has been
  4557.              defined and we are outputting an executable,
  4558.              resolve the indirection; it's no longer needed */
  4559. !         if (output_style != OUTPUT_RELOCATABLE
  4560. !             && ((sp->defined & ~N_EXT) == N_INDR)
  4561.               && (((symbol *) sp->value)->defined > 1))
  4562.             {
  4563.               symbol *newsp = (symbol *) sp->value;
  4564. ***************
  4565. *** 4152,4188 ****
  4566.           *bufp++ = nl;
  4567.           syms_written++;
  4568.           if (nl.n_type == (N_INDR | N_EXT))
  4569.             {
  4570.           struct nlist xtra_ref;
  4571.           xtra_ref.n_type == N_EXT | N_UNDF;
  4572.           xtra_ref.n_un.n_strx
  4573.             = assign_string_table_index (((symbol *) sp->value)->name);
  4574.           xtra_ref.n_other = 0;
  4575.           xtra_ref.n_desc = 0;
  4576.           xtra_ref.n_value = 0;
  4577.           *bufp++ = xtra_ref;
  4578.           syms_written++;
  4579.             }
  4580.         }
  4581.         }
  4582.   
  4583.     /* Output the buffer full of `struct nlist's.  */
  4584.   
  4585. !   lseek (outdesc, symbol_table_offset + symbol_table_len, 0);
  4586.     mywrite (buf, sizeof (struct nlist), bufp - buf, outdesc);
  4587. !   symbol_table_len += sizeof (struct nlist) * (bufp - buf);
  4588.   
  4589.     if (syms_written != nsyms)
  4590.       fatal ("internal error: wrong number of symbols written into output file", 0);
  4591.   
  4592. !   if (symbol_table_offset + symbol_table_len != string_table_offset)
  4593. !     fatal ("internal error: inconsistent symbol table length", 0);
  4594.   
  4595. !   /* Now the total string table size is known, so write it.
  4596. !      We are already positioned at the right place in the file.  */
  4597.   
  4598. -   mywrite (&strtab_size, sizeof (int), 1, outdesc);  /* we're at right place */
  4599. - 
  4600.     /* Write the strings for the global symbols.  */
  4601.   
  4602.     write_string_table ();
  4603. --- 5342,5389 ----
  4604.           *bufp++ = nl;
  4605.           syms_written++;
  4606.           if (nl.n_type == (N_INDR | N_EXT))
  4607. + #ifndef NeXT
  4608.             {
  4609.           struct nlist xtra_ref;
  4610.           xtra_ref.n_type == N_EXT | N_UNDF;
  4611.           xtra_ref.n_un.n_strx
  4612.             = assign_string_table_index (((symbol *) sp->value)->name);
  4613. + #ifdef N_SECT
  4614. +         xtra_ref.n_sect = 0;
  4615. + #else
  4616.           xtra_ref.n_other = 0;
  4617. + #endif
  4618.           xtra_ref.n_desc = 0;
  4619.           xtra_ref.n_value = 0;
  4620.           *bufp++ = xtra_ref;
  4621.           syms_written++;
  4622.             }
  4623. + #else
  4624. +         nl.n_value = assign_string_table_index (((symbol *) sp->value)->name);
  4625. + #endif
  4626.         }
  4627.         }
  4628.   
  4629. + #ifdef MACH_O
  4630. +   if (output_file_type == IS_MACH_O)
  4631. +     generate_mach_o_symbols(buf, bufp - buf);
  4632. + #endif
  4633. + 
  4634.     /* Output the buffer full of `struct nlist's.  */
  4635.   
  4636. !   lseek (outdesc, output_syms_offset + output_syms_size, 0);
  4637.     mywrite (buf, sizeof (struct nlist), bufp - buf, outdesc);
  4638. !   output_syms_size += sizeof (struct nlist) * (bufp - buf);
  4639.   
  4640.     if (syms_written != nsyms)
  4641.       fatal ("internal error: wrong number of symbols written into output file", 0);
  4642.   
  4643. !   /* Now the total string table size is known, so write it into the
  4644. !      first word of the string table.  */
  4645.   
  4646. !   lseek (outdesc, output_strs_offset, 0);
  4647. !   mywrite (&strtab_size, sizeof (int), 1, outdesc);
  4648.   
  4649.     /* Write the strings for the global symbols.  */
  4650.   
  4651.     write_string_table ();
  4652. ***************
  4653. *** 4200,4215 ****
  4654.        int *syms_written_addr;
  4655.   {
  4656.     register struct nlist *p = entry->symbols;
  4657. !   register struct nlist *end = p + entry->header.a_syms / sizeof (struct nlist);
  4658.   
  4659.     /* Buffer to accumulate all the syms before writing them.
  4660.        It has one extra slot for the local symbol we generate here.  */
  4661.     struct nlist *buf
  4662. !     = (struct nlist *) alloca (entry->header.a_syms + sizeof (struct nlist));
  4663.     register struct nlist *bufp = buf;
  4664.   
  4665.     /* Upper bound on number of syms to be written here.  */
  4666. !   int max_syms = (entry->header.a_syms / sizeof (struct nlist)) + 1;
  4667.   
  4668.     /* Make tables that record, for each symbol, its name and its name's length.
  4669.        The elements are filled in by `assign_string_table_index'.  */
  4670. --- 5401,5416 ----
  4671.        int *syms_written_addr;
  4672.   {
  4673.     register struct nlist *p = entry->symbols;
  4674. !   register struct nlist *end = p + entry->syms_size / sizeof (struct nlist);
  4675.   
  4676.     /* Buffer to accumulate all the syms before writing them.
  4677.        It has one extra slot for the local symbol we generate here.  */
  4678.     struct nlist *buf
  4679. !     = (struct nlist *) alloca (entry->syms_size + sizeof (struct nlist));
  4680.     register struct nlist *bufp = buf;
  4681.   
  4682.     /* Upper bound on number of syms to be written here.  */
  4683. !   int max_syms = (entry->syms_size / sizeof (struct nlist)) + 1;
  4684.   
  4685.     /* Make tables that record, for each symbol, its name and its name's length.
  4686.        The elements are filled in by `assign_string_table_index'.  */
  4687. ***************
  4688. *** 4228,4234 ****
  4689. --- 5429,5439 ----
  4690.         nl.n_un.n_strx = assign_string_table_index (entry->local_sym_name);
  4691.         nl.n_value = entry->text_start_address;
  4692.         nl.n_desc = 0;
  4693. + #ifdef N_SECT
  4694. +       nl.n_sect = 0;
  4695. + #else
  4696.         nl.n_other = 0;
  4697. + #endif
  4698.         *bufp++ = nl;
  4699.         (*syms_written_addr)++;
  4700.         entry->local_syms_offset = *syms_written_addr * sizeof (struct nlist);
  4701. ***************
  4702. *** 4236,4242 ****
  4703.   
  4704.     /* Read the file's string table.  */
  4705.   
  4706. !   entry->strings = (char *) alloca (entry->string_size);
  4707.     read_entry_strings (file_open (entry), entry);
  4708.   
  4709.     for (; p < end; p++)
  4710. --- 5441,5447 ----
  4711.   
  4712.     /* Read the file's string table.  */
  4713.   
  4714. !   entry->strings = (char *) alloca (entry->strs_size);
  4715.     read_entry_strings (file_open (entry), entry);
  4716.   
  4717.     for (; p < end; p++)
  4718. ***************
  4719. *** 4251,4257 ****
  4720.                   /* types of symbols are never written */
  4721.                   /* globally, though they are stored */
  4722.                   /* globally.  */
  4723. !         write = relocatable_output;
  4724.         else if (!(type & (N_STAB | N_EXT)))
  4725.           /* ordinary local symbol */
  4726.       write = ((discard_locals != DISCARD_ALL)
  4727. --- 5456,5462 ----
  4728.                   /* types of symbols are never written */
  4729.                   /* globally, though they are stored */
  4730.                   /* globally.  */
  4731. !         write = output_style == OUTPUT_RELOCATABLE;
  4732.         else if (!(type & (N_STAB | N_EXT)))
  4733.           /* ordinary local symbol */
  4734.       write = ((discard_locals != DISCARD_ALL)
  4735. ***************
  4736. *** 4278,4288 ****
  4737.       }
  4738.       }
  4739.   
  4740.     /* All the symbols are now in BUF; write them.  */
  4741.   
  4742. !   lseek (outdesc, symbol_table_offset + symbol_table_len, 0);
  4743.     mywrite (buf, sizeof (struct nlist), bufp - buf, outdesc);
  4744. !   symbol_table_len += sizeof (struct nlist) * (bufp - buf);
  4745.   
  4746.     /* Write the string-table data for the symbols just written,
  4747.        using the data in vectors `strtab_vector' and `strtab_lens'.  */
  4748. --- 5483,5498 ----
  4749.       }
  4750.       }
  4751.   
  4752. + #ifdef MACH_O
  4753. +   if (output_file_type == IS_MACH_O)
  4754. +     generate_mach_o_symbols(buf, bufp - buf);
  4755. + #endif
  4756. + 
  4757.     /* All the symbols are now in BUF; write them.  */
  4758.   
  4759. !   lseek (outdesc, output_syms_offset + output_syms_size, 0);
  4760.     mywrite (buf, sizeof (struct nlist), bufp - buf, outdesc);
  4761. !   output_syms_size += sizeof (struct nlist) * (bufp - buf);
  4762.   
  4763.     /* Write the string-table data for the symbols just written,
  4764.        using the data in vectors `strtab_vector' and `strtab_lens'.  */
  4765. ***************
  4766. *** 4300,4305 ****
  4767. --- 5510,5516 ----
  4768.   void
  4769.   write_symsegs ()
  4770.   {
  4771. +   lseek (outdesc, output_symseg_offset, 0);
  4772.     each_file (write_file_symseg, 0);
  4773.   }
  4774.   
  4775. ***************
  4776. *** 4309,4320 ****
  4777.   {
  4778.     char buffer[4096];
  4779.     struct symbol_root root;
  4780. !   int indesc;
  4781. !   int len;
  4782.   
  4783. !   if (entry->symseg_offset == 0)
  4784.       return;
  4785.   
  4786.     /* This entry has a symbol segment.  Read the root of the segment.  */
  4787.   
  4788.     indesc = file_open (entry);
  4789. --- 5520,5532 ----
  4790.   {
  4791.     char buffer[4096];
  4792.     struct symbol_root root;
  4793. !   int indesc, len, total;
  4794.   
  4795. !   if (entry->symseg_size == 0)
  4796.       return;
  4797.   
  4798. +   output_symseg_size += entry->symseg_size;
  4799. + 
  4800.     /* This entry has a symbol segment.  Read the root of the segment.  */
  4801.   
  4802.     indesc = file_open (entry);
  4803. ***************
  4804. *** 4325,4334 ****
  4805.     /* Store some relocation info into the root.  */
  4806.   
  4807.     root.ldsymoff = entry->local_syms_offset;
  4808. !   root.textrel = entry->text_start_address;
  4809. !   root.datarel = entry->data_start_address - entry->header.a_text;
  4810. !   root.bssrel = entry->bss_start_address
  4811. !     - entry->header.a_text - entry->header.a_data;
  4812.     root.databeg = entry->data_start_address - root.datarel;
  4813.     root.bssbeg = entry->bss_start_address - root.bssrel;
  4814.   
  4815. --- 5537,5545 ----
  4816.     /* Store some relocation info into the root.  */
  4817.   
  4818.     root.ldsymoff = entry->local_syms_offset;
  4819. !   root.textrel = entry->text_start_address - entry->orig_text_address;
  4820. !   root.datarel = entry->data_start_address - entry->orig_data_address;
  4821. !   root.bssrel = entry->bss_start_address - entry->orig_bss_address;
  4822.     root.databeg = entry->data_start_address - root.datarel;
  4823.     root.bssbeg = entry->bss_start_address - root.bssrel;
  4824.   
  4825. ***************
  4826. *** 4338,4349 ****
  4827.   
  4828.     /* Copy the rest of the symbol segment unchanged.  */
  4829.   
  4830. !   if (entry->superfile)
  4831. !     {
  4832. !       /* Library member: number of bytes to copy is determined
  4833. !      from the member's total size.  */
  4834. ! 
  4835. !       int total = entry->total_size - entry->symseg_offset - sizeof root;
  4836.   
  4837.         while (total > 0)
  4838.       {
  4839. --- 5549,5555 ----
  4840.   
  4841.     /* Copy the rest of the symbol segment unchanged.  */
  4842.   
  4843. !   total = entry->symseg_size - sizeof root;
  4844.   
  4845.     while (total > 0)
  4846.       {
  4847. ***************
  4848. *** 4354,4414 ****
  4849.         total -= len;
  4850.         mywrite (buffer, len, 1, outdesc);
  4851.       }
  4852.       }
  4853.     else
  4854.       {
  4855. !       /* A separate file: copy until end of file.  */
  4856. ! 
  4857. !       while (len = read (indesc, buffer, sizeof buffer))
  4858. !     {
  4859. !       mywrite (buffer, len, 1, outdesc);
  4860. !       if (len < sizeof buffer)
  4861. !         break;
  4862.       }
  4863.       }
  4864.   
  4865. -   file_close ();
  4866. - }
  4867. - 
  4868.   /* Create the symbol table entries for `etext', `edata' and `end'.  */
  4869.   
  4870.   void
  4871.   symtab_init ()
  4872.   {
  4873. ! #ifndef nounderscore
  4874. !   edata_symbol = getsym ("_edata");
  4875. !   etext_symbol = getsym ("_etext");
  4876. !   end_symbol = getsym ("_end");
  4877. ! #else
  4878. !   edata_symbol = getsym ("edata");
  4879. !   etext_symbol = getsym ("etext");
  4880. !   end_symbol = getsym ("end");
  4881. ! #endif
  4882.   
  4883.   #ifdef sun
  4884.     {
  4885. !     symbol *dynamic_symbol = getsym ("__DYNAMIC");
  4886. !     dynamic_symbol->defined = N_ABS | N_EXT;
  4887. !     dynamic_symbol->referenced = 1;
  4888.       dynamic_symbol->value = 0;
  4889.     }
  4890.   #endif
  4891.   #ifdef sequent
  4892.     {
  4893. !     symbol *_387_flt_symbol = getsym ("_387_flt");
  4894. !     _387_flt_symbol->defined = N_ABS | N_EXT;
  4895. !     _387_flt_symbol->referenced = 1;
  4896. !     _387_flt_symbol->value = 0;
  4897.     }
  4898. ! #endif
  4899. ! 
  4900. !   edata_symbol->defined = N_DATA | N_EXT;
  4901. !   etext_symbol->defined = N_TEXT | N_EXT;
  4902. !   end_symbol->defined = N_BSS | N_EXT;
  4903. ! 
  4904. !   edata_symbol->referenced = 1;
  4905. !   etext_symbol->referenced = 1;
  4906. !   end_symbol->referenced = 1;
  4907.   }
  4908.   
  4909.   /* Compute the hash code for symbol name KEY.  */
  4910. --- 5560,5646 ----
  4911.         total -= len;
  4912.         mywrite (buffer, len, 1, outdesc);
  4913.       }
  4914. + 
  4915. +   file_close ();
  4916. + }
  4917. + 
  4918. + /* Define a special symbol (etext, edata, or end).  NAME is the
  4919. +    name of the symbol, with a leading underscore (whether or not this
  4920. +    system uses such underscores).  TYPE is its type (e.g. N_DATA | N_EXT).
  4921. +    Store a symbol * for the symbol in *SYM if SYM is non-NULL.  */
  4922. + static void
  4923. + symbol_define (name, type, sym)
  4924. +      /* const */ char *name;
  4925. +      int type;
  4926. +      symbol **sym;
  4927. + {
  4928. +   symbol *thesym;
  4929. + 
  4930. + #if defined(nounderscore)
  4931. +   /* Skip the leading underscore.  */
  4932. +   name++;
  4933. + #endif
  4934. + 
  4935. +   thesym = getsym (name);
  4936. +   if (thesym->defined)
  4937. +     {
  4938. +       /* The symbol is defined in some input file.  Don't mess with it.  */
  4939. +       if (sym)
  4940. +     *sym = 0;
  4941.       }
  4942.     else
  4943.       {
  4944. !       if (thesym->referenced)
  4945. !     /* The symbol was not defined, and we are defining it now.  */
  4946. !     undefined_global_sym_count--;
  4947. !       thesym->defined = type;
  4948. !       thesym->referenced = 1;
  4949. !       if (sym)
  4950. !     *sym = thesym;
  4951.       }
  4952.   }
  4953.   
  4954.   /* Create the symbol table entries for `etext', `edata' and `end'.  */
  4955.   
  4956.   void
  4957.   symtab_init ()
  4958.   {
  4959. !   symbol_define ("_edata", N_DATA | N_EXT, &edata_symbol);
  4960. !   symbol_define ("_etext", N_TEXT | N_EXT, &etext_symbol);
  4961. !   symbol_define ("_end", N_BSS | N_EXT, &end_symbol);
  4962. ! 
  4963. !   /* Either _edata or __edata (C names) is OK as far as ANSI is concerned
  4964. !      (see section 4.1.2.1).  In general, it is best to use __foo and
  4965. !      not worry about the confusing rules for the _foo namespace.
  4966. !      But HPUX 7.0 uses _edata, so we might as weel be consistent.  */
  4967. !   symbol_define ("__edata", N_DATA | N_EXT, &edata_symbol_alt);
  4968. !   symbol_define ("__etext", N_TEXT | N_EXT, &etext_symbol_alt);
  4969. !   symbol_define ("__end", N_BSS | N_EXT, &end_symbol_alt);
  4970.   
  4971.   #ifdef sun
  4972.     {
  4973. !     symbol *dynamic_symbol;
  4974. !     symbol_define ("__DYNAMIC", N_ABS | N_EXT, &dynamic_symbol);
  4975. !     if (dynamic_symbol)
  4976.         dynamic_symbol->value = 0;
  4977.     }
  4978.   #endif
  4979.   #ifdef sequent
  4980.     {
  4981. !     symbol *i387_flt_symbol;
  4982. !     symbol_define ("_387_flt", N_ABS | N_EXT, &i387_flt_symbol);
  4983. !     if (i387_flt_symbol)
  4984. !       i387_flt_symbol->value = 0;
  4985.     }
  4986. ! #endif
  4987. ! #ifdef NeXT
  4988. !   {
  4989. !     symbol *shlib_init_symbol;
  4990. !     symbol_define ("__shared_library_initialization", N_UNDF | N_EXT, &shlib_init_symbol);
  4991. !     if (shlib_init_symbol)
  4992. !       shlib_init_symbol->max_common_size = sizeof (long int);
  4993. !   }
  4994. ! #endif
  4995.   }
  4996.   
  4997.   /* Compute the hash code for symbol name KEY.  */
  4998. ***************
  4999. *** 4495,4500 ****
  5000. --- 5727,5754 ----
  5001.     return 0;
  5002.   }
  5003.   
  5004. + /* Report a usage error.
  5005. +    Like fatal except prints a usage summary.  */
  5006. + 
  5007. + void
  5008. + usage (string, arg)
  5009. +      char *string, *arg;
  5010. + {
  5011. +   if (string)
  5012. +     {
  5013. +       fprintf (stderr, "%s: ", progname);
  5014. +       fprintf (stderr, string, arg);
  5015. +       fprintf (stderr, "\n");
  5016. +     }
  5017. +   fprintf (stderr, "\
  5018. + Usage: %s [-d] [-dc] [-dp] [-e symbol] [-l lib] [-n] [-noinhibit-exec]\n\
  5019. +        [-nostdlib] [-o file] [-r] [-s] [-t] [-u symbol] [-x] [-y symbol]\n\
  5020. +        [-z] [-A file] [-Bstatic] [-D size] [-L libdir] [-M] [-N]\n\
  5021. +        [-S] [-T[{text,data}] addr] [-V prefix] [-X] [file...]\n",
  5022. +        progname);
  5023. +   exit (1);
  5024. + }
  5025. + 
  5026.   /* Report a fatal error.
  5027.      STRING is a printf format string and ARG is one arg for it.  */
  5028.   
  5029. ***************
  5030. *** 4502,4508 ****
  5031.   fatal (string, arg)
  5032.        char *string, *arg;
  5033.   {
  5034. !   fprintf (stderr, "ld: ");
  5035.     fprintf (stderr, string, arg);
  5036.     fprintf (stderr, "\n");
  5037.     exit (1);
  5038. --- 5756,5762 ----
  5039.   fatal (string, arg)
  5040.        char *string, *arg;
  5041.   {
  5042. !   fprintf (stderr, "%s: ", progname);
  5043.     fprintf (stderr, string, arg);
  5044.     fprintf (stderr, "\n");
  5045.     exit (1);
  5046. ***************
  5047. *** 4516,4522 ****
  5048.        char *string;
  5049.        struct file_entry *entry;
  5050.   {
  5051. !   fprintf (stderr, "ld: ");
  5052.     fprintf (stderr, string);
  5053.     print_file_name (entry, stderr);
  5054.     fprintf (stderr, "\n");
  5055. --- 5770,5776 ----
  5056.        char *string;
  5057.        struct file_entry *entry;
  5058.   {
  5059. !   fprintf (stderr, "%s: ", progname);
  5060.     fprintf (stderr, string);
  5061.     print_file_name (entry, stderr);
  5062.     fprintf (stderr, "\n");
  5063. ***************
  5064. *** 4646,4656 ****
  5065.   
  5066.   /* Like malloc but get fatal error if memory is exhausted.  */
  5067.   
  5068. ! int
  5069.   xmalloc (size)
  5070.        int size;
  5071.   {
  5072. !   register int result = malloc (size);
  5073.     if (!result)
  5074.       fatal ("virtual memory exhausted", 0);
  5075.     return result;
  5076. --- 5900,5910 ----
  5077.   
  5078.   /* Like malloc but get fatal error if memory is exhausted.  */
  5079.   
  5080. ! char *
  5081.   xmalloc (size)
  5082.        int size;
  5083.   {
  5084. !   register char *result = malloc (size);
  5085.     if (!result)
  5086.       fatal ("virtual memory exhausted", 0);
  5087.     return result;
  5088. ***************
  5089. *** 4658,4669 ****
  5090.   
  5091.   /* Like realloc but get fatal error if memory is exhausted.  */
  5092.   
  5093. ! int
  5094.   xrealloc (ptr, size)
  5095.        char *ptr;
  5096.        int size;
  5097.   {
  5098. !   register int result = realloc (ptr, size);
  5099.     if (!result)
  5100.       fatal ("virtual memory exhausted", 0);
  5101.     return result;
  5102. --- 5912,5923 ----
  5103.   
  5104.   /* Like realloc but get fatal error if memory is exhausted.  */
  5105.   
  5106. ! char *
  5107.   xrealloc (ptr, size)
  5108.        char *ptr;
  5109.        int size;
  5110.   {
  5111. !   register char *result = realloc (ptr, size);
  5112.     if (!result)
  5113.       fatal ("virtual memory exhausted", 0);
  5114.     return result;
  5115. ***************
  5116. *** 4690,4693 ****
  5117. --- 5944,5955 ----
  5118.     return (4096);
  5119.   }
  5120.   
  5121. + #endif
  5122. + 
  5123. + #if defined(sun) && defined(sparc)
  5124. + int
  5125. + getpagesize ()
  5126. + {
  5127. +   return 8192;
  5128. + }
  5129.   #endif
  5130.